/***************************************************************************\
* AddInstance
*
* Description:
* Adds a server side instance handle to the instance handle array.
* The array index becomes the client-side unique instance index used for
* identifying other client side handles.
*
* Returns:
* client side instance handle or 0 on error.
*
* History:
* 11-1-91 sanfords Created.
\***************************************************************************/
DWORD AddInstance(
HANDLE hInstServer)
{
int i, iNextFree;
PHANDLE ph;
if (iFirstFreeInst >= cInstAllocated) {
if (cInstAllocated == 0) {
aInstance = (PHANDLE)DDEMLAlloc(sizeof(HANDLE) * INST_GROW_COUNT);
} else {
aInstance = (PHANDLE)DDEMLReAlloc((PVOID)aInstance,
sizeof(HANDLE) * (cInstAllocated + INST_GROW_COUNT));
}
if (aInstance == 0) {
return (0);
}
ph = &aInstance[cInstAllocated];
i = cInstAllocated + 1;
while (i <= cInstAllocated + INST_GROW_COUNT) {
*ph++ = (HANDLE)i++;
}
cInstAllocated += INST_GROW_COUNT;
}
iNextFree = (int)aInstance[iFirstFreeInst];
if (iNextFree > MAX_INST) {
/*
* Instance limit for this process exceeded!
*/
return(0);
}
aInstance[iFirstFreeInst] = hInstServer;
i = iFirstFreeInst;
iFirstFreeInst = iNextFree;
return ((DWORD)CreateHandle(0, HTYPE_INSTANCE, i));
}
void Collider3D::ComputeInertialMatrix(Vector3f* inertia, Vector3f* center) const
{
float inertiaMatrix[3];
float origin[3];
// Si nous n'avons aucune instance, nous en créons une temporaire
if (m_handles.empty())
{
PhysWorld3D world;
NewtonCollision* collision = CreateHandle(&world);
{
NewtonConvexCollisionCalculateInertialMatrix(collision, inertiaMatrix, origin);
}
NewtonDestroyCollision(collision);
}
else // Sinon on utilise une instance au hasard (elles sont toutes identiques de toute façon)
NewtonConvexCollisionCalculateInertialMatrix(m_handles.begin()->second, inertiaMatrix, origin);
if (inertia)
inertia->Set(inertiaMatrix);
if (center)
center->Set(origin);
}
void Collider3D::ComputeInertialMatrix(Vector3f* inertia, Vector3f* center) const
{
float inertiaMatrix[3];
float origin[3];
// Check for existing collision handles, and create a temporary one if none is available
if (m_handles.empty())
{
PhysWorld3D world;
NewtonCollision* collision = CreateHandle(&world);
{
NewtonConvexCollisionCalculateInertialMatrix(collision, inertiaMatrix, origin);
}
NewtonDestroyCollision(collision);
}
else
NewtonConvexCollisionCalculateInertialMatrix(m_handles.begin()->second, inertiaMatrix, origin);
if (inertia)
inertia->Set(inertiaMatrix);
if (center)
center->Set(origin);
}
/**
* Returns -1 if command queue or pickup pool is full, 0 on success (will be
* called by audio thread within the voice class).
*/
int DiskThread::OrderNewStream(Stream::reference_t* pStreamRef, ::gig::DimensionRegion* pDimRgn, unsigned long SampleOffset, bool DoLoop) {
dmsg(4,("Disk Thread: new stream ordered\n"));
if (CreationQueue->write_space() < 1) {
dmsg(1,("DiskThread: Order queue full!\n"));
return -1;
}
const Stream::OrderID_t newOrder = CreateOrderID();
if (!newOrder) {
dmsg(1,("DiskThread: there was no free slot\n"));
return -1; // there was no free slot
}
pStreamRef->State = Stream::state_active;
pStreamRef->OrderID = newOrder;
pStreamRef->hStream = CreateHandle();
pStreamRef->pStream = NULL; // a stream has to be activated by the disk thread first
create_command_t cmd;
cmd.OrderID = pStreamRef->OrderID;
cmd.hStream = pStreamRef->hStream;
cmd.pStreamRef = pStreamRef;
cmd.pDimRgn = pDimRgn;
cmd.SampleOffset = SampleOffset;
cmd.DoLoop = DoLoop;
CreationQueue->push(&cmd);
return 0;
}
NewtonCollision* Collider3D::GetHandle(PhysWorld3D* world) const
{
auto it = m_handles.find(world);
if (it == m_handles.end())
it = m_handles.insert(std::make_pair(world, CreateHandle(world))).first;
return it->second;
}
THandle OsNetworkCreate(OsNetworkSocketType aSocketType)
{
int32_t socketH = socket(2, aSocketType, 0);
OsNetworkHandle* handle = CreateHandle(socketH);
if (handle == kHandleNull) {
TEMP_FAILURE_RETRY(close(socketH));
}
return (THandle)handle;
}
THandle OsNetworkCreate(OsContext* aContext, OsNetworkSocketType aSocketType)
{
int32_t socketH = socket(2, aSocketType, 0);
OsNetworkHandle* handle = CreateHandle(aContext, socketH);
if (handle == kHandleNull) {
/* close is the one networking call that is exempt from being wrapped by TEMP_FAILURE_RETRY. See
https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain */
close(socketH);
}
return (THandle)handle;
}
void GameWindow::SetPosition(Point2 value)
{
if (handle == nullptr)
CreateHandle();
if (position != value)
{
position = value;
::SetWindowPos(static_cast<HWND>(handle), nullptr, position.X, position.Y, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
}
}
VFSHandle * VFSTransport::OpenLocation(char *loc, bool create)
{
VFSHandle *handle = CreateHandle(this);
if(handle->OpenLocation(loc,create) == true){
m_handles.push_back(handle);
return handle;
}
delete[] handle;
return NULL;
}
/* Get a new Tax ID given an old Tax ID from the merged node database */
Int4 DB_GetTaxMergedNodeRecNewTIDByOldTID(Int4 oldTaxId)
{
CharPtr search_mergeddb = "select new_taxid from seqhound.mergedtaxdb where old_taxid=?";
SQLHANDLE hstmt;
Int4 new_value = -1;
Int2 sqlrc=SQL_SUCCESS;
struct{
Int4 len;
Int4 val;
}new_id;
/* search merged db*/
CreateHandle(&hstmt,search_mergeddb,&henv, &hdbc);
SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_LONG,SQL_INTEGER, 0, 0, &oldTaxId, 0, NULL);
/* set auto commit on */
SQLSetConnectAttr( hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS);
/* execute statment */
if (SQLExecute(hstmt) != SQL_SUCCESS){
ErrPostEx(SEV_ERROR,0,0,"DB_GetTaxMergedNodeRecNewTIDByOldTID:unable to execute select statement.");
print_err(hstmt);
SQLFreeStmt(hstmt, SQL_DROP);
return FALSE;
}
SQLBindCol(hstmt,1,SQL_C_LONG,&new_id.val,10,(long*)&new_id.len);
sqlrc = SQLFetch(hstmt);
if(sqlrc == SQL_NO_DATA_FOUND){
ErrPostEx(SEV_INFO, 0, 0, "Old Tax ID: %ld not found in Mergedtaxdb.", oldTaxId);
return(-1);
}
else if(sqlrc == SQL_SUCCESS || sqlrc == SQL_SUCCESS_WITH_INFO){
new_value = new_id.val;
}
else{
print_err(hstmt);
return (-1);
}
/* Free statement handle. */
if(SQLFreeStmt(hstmt, SQL_DROP) != SQL_SUCCESS){
print_err(hstmt);
return (-1);
}
return(new_value);
}
/* Replace an SLRI-Taxon record in the database */
Int2 DB_ReplaceTaxRec(SLRITaxonPtr stp)
{
Int4 bsLength=0;
pABL Asnbuflen=NULL;
Int4 taxid;
CharPtr asn1;
SQLHANDLE hstmt;
CharPtr update = "update seqhound.taxdb set asn1=? where taxid = ?";
if(stp == NULL) {
ErrPostEx(SEV_INFO, 3, 0, "DB_WriteTaxRec: Passed ASN.1 pointer is null.");
return(-1);
}
CreateHandle(&hstmt,update,&henv,&hdbc);
/*get the asn1 bioseq into a bytestore pointer so that we can put it into a buffer.*/
Asnbuflen = AssignASNMemChar((Pointer) stp, (AsnWriteFunc) SLRITaxonAsnWrite);
/* SK: NULL ptr check */
if(Asnbuflen == NULL) {
ErrPostEx(SEV_INFO, 3, 0, "DB_ReplaceTaxRec: NULL Asnbuflen.");
return(-1);
}
asn1 = Asnbuflen->buf;
bsLength = Asnbuflen->len;
/*set up the input parameters */
SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_DEFAULT,SQL_BLOB, 0, 0, asn1, 0, (long*)&bsLength);
SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_LONG,SQL_INTEGER, 0, 0, &taxid, 0, NULL);
taxid = stp->taxId;
/* execute statment */
if (SQLExecute (hstmt) != SQL_SUCCESS){
ErrPostEx(SEV_ERROR,0,0, "DB_ReplaceTax: unable to execute insert statement. ");
print_err(hstmt);
return FALSE;
}
asn1 = MemFree(asn1);
/* pABLtmp->buf = MemFree(pABLtmp->buf);*/
FreeABL(Asnbuflen);
if(SQLFreeStmt(hstmt, SQL_DROP) != SQL_SUCCESS){
print_err(hstmt);
return FALSE;
}
return TRUE;
}
THandle OsNetworkAccept(THandle aHandle, TIpAddress* aClientAddress, uint32_t* aClientPort)
{
SOCKET h;
OsNetworkHandle* newHandle;
OsNetworkHandle* handle = (OsNetworkHandle*)aHandle;
WSAEVENT event;
HANDLE handles[2];
DWORD ret;
struct sockaddr_in addr;
socklen_t len = sizeof(addr);
*aClientAddress = 0;
*aClientPort = 0;
if (SocketInterrupted(handle)) {
return kHandleNull;
}
sockaddrFromEndpoint(&addr, 0, 0);
event = WSACreateEvent();
if (NULL == event) {
return kHandleNull;
}
if (0 != WSAEventSelect(handle->iSocket, event, FD_ACCEPT|FD_CLOSE)) {
WSACloseEvent(event);
return kHandleNull;
}
h = accept(handle->iSocket, (struct sockaddr*)&addr, &len);
if (INVALID_SOCKET==h && WSAEWOULDBLOCK==WSAGetLastError()) {
handles[0] = event;
handles[1] = handle->iEvent;
ret = WSAWaitForMultipleEvents(2, &handles[0], FALSE, INFINITE, FALSE);
if (WAIT_OBJECT_0 == ret) {
h = accept(handle->iSocket, (struct sockaddr*)&addr, &len);
}
}
SetSocketBlocking(handle->iSocket);
WSACloseEvent(event);
if (INVALID_SOCKET == h) {
return kHandleNull;
}
newHandle = CreateHandle(handle->iCtx, h);
if (NULL == newHandle) {
return kHandleNull;
}
*aClientAddress = addr.sin_addr.s_addr;
*aClientPort = SwapEndian16(addr.sin_port);
return (THandle)newHandle;
}
/** Opens a file
*
* @param filename The name of the file being opened
* @param plugin The plugin to be used to decode the file data
* @param create Whether to create a non-existant file, or return a false upon attempting to open
*
* Operation:
* -# Creates a new handle
* -# Move the pointer along the string to remove the transport identifier
* -# Requests the handle open the file
* -# Sets the plugin of the new handle
* -# if opening the file was successful, returns the new file handle
* -# Otherwise, handle is deleted and NULL is returned
*/
VFSHandle * VFSTransport::Open(char *filename, VFSPlugin *plugin, bool create)
{
VFSHandle *handle = CreateHandle(this);
handle->SetPlugin(plugin);
if(handle->Open(filename, create) == true){
m_handles.push_back(handle);
return handle;
}
delete handle;
return NULL;
}
void GameWindow::MoveToScreenCenter()
{
if (handle == nullptr)
CreateHandle();
RECT windowRect = { 0, 0, 0, 0 };
if (::GetWindowRect(static_cast<HWND>(handle), &windowRect))
{
const SIZE screenSize = { GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN) };
const SIZE windowSize = { windowRect.right - windowRect.left, windowRect.bottom - windowRect.top };
const POINT windowPosition = { (screenSize.cx - windowSize.cx) / 2, (screenSize.cy - windowSize.cy) / 2 };
SetPosition(Point2(windowPosition.x, windowPosition.y));
}
}
void GameWindow::SetTitle(const String& value)
{
if (handle == nullptr)
CreateHandle();
if (title != value)
{
title = value;
std::vector<wchar_t> wideCharacters;
wideCharacters.resize(MultiByteToWideChar(CP_UTF8, 0, title.CStr(), title.GetLength(), nullptr, 0) + 1, L'\0');
MultiByteToWideChar(CP_UTF8, 0, title.CStr(), title.GetLength(), &wideCharacters[0], wideCharacters.size());
::SetWindowTextW(static_cast<HWND>(handle), &wideCharacters[0]);
}
}
void GameWindow::SetVisible(bool value)
{
if (handle == nullptr)
CreateHandle();
if (visible != value)
{
visible = value;
int showCommand = SW_HIDE;
if (visible)
showCommand = SW_SHOW;
::ShowWindow(static_cast<HWND>(handle), showCommand);
}
}
THandle OsNetworkAccept(THandle aHandle, TIpAddress* aClientAddress, uint32_t* aClientPort)
{
OsNetworkHandle* handle = (OsNetworkHandle*)aHandle;
*aClientAddress = 0;
*aClientPort = 0;
if (SocketInterrupted(handle)) {
return kHandleNull;
}
struct sockaddr_in addr;
sockaddrFromEndpoint(&addr, 0, 0);
socklen_t len = sizeof(addr);
SetFdNonBlocking(handle->iSocket);
fd_set read;
FD_ZERO(&read);
FD_SET(handle->iPipe[0], &read);
FD_SET(handle->iSocket, &read);
fd_set error;
FD_ZERO(&error);
FD_SET(handle->iSocket, &error);
int32_t h = TEMP_FAILURE_RETRY_2(accept(handle->iSocket, (struct sockaddr*)&addr, &len), handle);
if (h==-1 && errno==EWOULDBLOCK) {
int32_t selectErr = TEMP_FAILURE_RETRY_2(select(nfds(handle), &read, NULL, &error, NULL), handle);
if (selectErr > 0 && FD_ISSET(handle->iSocket, &read)) {
h = TEMP_FAILURE_RETRY_2(accept(handle->iSocket, (struct sockaddr*)&addr, &len), handle);
}
}
SetFdBlocking(handle->iSocket);
if (h == -1) {
return kHandleNull;
}
OsNetworkHandle* newHandle = CreateHandle(handle->iCtx, h);
if (newHandle == NULL) {
close(h);
return kHandleNull;
}
*aClientAddress = addr.sin_addr.s_addr;
*aClientPort = ntohs(addr.sin_port);
return (THandle)newHandle;
}
void GameWindow::SetSize(Point2 value)
{
if (handle == nullptr)
CreateHandle();
if (GetSize() != value)
{
size = value;
const DWORD exWindowStyle = static_cast<DWORD>(GetWindowLong(static_cast<HWND>(handle), GWL_EXSTYLE));
const DWORD windowStyle = static_cast<DWORD>(GetWindowLong(static_cast<HWND>(handle), GWL_STYLE));
const BOOL hasMenu = GetMenu(static_cast<HWND>(handle)) != nullptr ? TRUE : FALSE;
RECT windowRect = { 0, 0, size.X, size.Y };
::AdjustWindowRectEx(&windowRect, windowStyle, hasMenu, exWindowStyle);
const SIZE windowSize = { windowRect.right - windowRect.left, windowRect.bottom - windowRect.top };
::SetWindowPos(static_cast<HWND>(handle), nullptr, 0, 0, windowSize.cx, windowSize.cy, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
}
}
static void SetInterfaceChangedObserver_Linux(OsContext* aContext, InterfaceListChanged aCallback, void* aArg)
{
struct sockaddr_nl addr;
int sock = 0;
aContext->iInterfaceChangedObserver = (InterfaceChangedObserver*) calloc(1, sizeof(InterfaceChangedObserver));
if (aContext->iInterfaceChangedObserver == NULL) {
goto Error;
}
if ((sock = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) == -1) {
goto Error;
}
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
addr.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR;
if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
close(sock);
goto Error;
}
if ((aContext->iInterfaceChangedObserver->netHnd = CreateHandle(aContext, sock)) == NULL) {
close(sock);
goto Error;
}
aContext->iInterfaceChangedObserver->iCallback = aCallback;
aContext->iInterfaceChangedObserver->iArg = aArg;
if ((aContext->iInterfaceChangedObserver->iThread = DoThreadCreate(aContext,
"AdapterChangeObserverThread",
100, 16 * 1024, 1,
adapterChangeObserverThread,
aContext->iInterfaceChangedObserver)) == NULL) {
goto Error;
}
return;
Error:
DestroyInterfaceChangedObserver_Linux(aContext);
}
float Collider3D::ComputeVolume() const
{
float volume;
// Si nous n'avons aucune instance, nous en créons une temporaire
if (m_handles.empty())
{
PhysWorld3D world;
NewtonCollision* collision = CreateHandle(&world);
{
volume = NewtonConvexCollisionCalculateVolume(collision);
}
NewtonDestroyCollision(collision);
}
else // Sinon on utilise une instance au hasard (elles sont toutes identiques de toute façon)
volume = NewtonConvexCollisionCalculateVolume(m_handles.begin()->second);
return volume;
}
Boxf Collider3D::ComputeAABB(const Matrix4f& offsetMatrix, const Vector3f& scale) const
{
Vector3f min, max;
// Si nous n'avons aucune instance, nous en créons une temporaire
if (m_handles.empty())
{
PhysWorld3D world;
NewtonCollision* collision = CreateHandle(&world);
{
NewtonCollisionCalculateAABB(collision, offsetMatrix, min, max);
}
NewtonDestroyCollision(collision);
}
else // Sinon on utilise une instance au hasard (elles sont toutes identiques de toute façon)
NewtonCollisionCalculateAABB(m_handles.begin()->second, offsetMatrix, min, max);
return Boxf(scale * min, scale * max);
}
Boxf Collider3D::ComputeAABB(const Matrix4f& offsetMatrix, const Vector3f& scale) const
{
Vector3f min, max;
// Check for existing collision handles, and create a temporary one if none is available
if (m_handles.empty())
{
PhysWorld3D world;
NewtonCollision* collision = CreateHandle(&world);
{
NewtonCollisionCalculateAABB(collision, offsetMatrix, min, max);
}
NewtonDestroyCollision(collision);
}
else
NewtonCollisionCalculateAABB(m_handles.begin()->second, offsetMatrix, min, max);
return Boxf(scale * min, scale * max);
}
float Collider3D::ComputeVolume() const
{
float volume;
// Check for existing collision handles, and create a temporary one if none is available
if (m_handles.empty())
{
PhysWorld3D world;
NewtonCollision* collision = CreateHandle(&world);
{
volume = NewtonConvexCollisionCalculateVolume(collision);
}
NewtonDestroyCollision(collision);
}
else
volume = NewtonConvexCollisionCalculateVolume(m_handles.begin()->second);
return volume;
}
static UCHAR EmsAlloc(USHORT NumPages, PUSHORT Handle)
{
ULONG i, CurrentIndex = 0;
PEMS_HANDLE HandleEntry;
if (NumPages == 0) return EMS_STATUS_ZERO_PAGES;
HandleEntry = CreateHandle(Handle);
if (!HandleEntry) return EMS_STATUS_NO_MORE_HANDLES;
while (HandleEntry->PageCount < NumPages)
{
ULONG RunStart;
ULONG RunSize = RtlFindNextForwardRunClear(&AllocBitmap, CurrentIndex, &RunStart);
if (RunSize == 0)
{
/* Free what's been allocated already and report failure */
EmsFree(*Handle);
return EMS_STATUS_INSUFFICIENT_PAGES;
}
else if ((HandleEntry->PageCount + RunSize) > NumPages)
{
/* We don't need the entire run */
RunSize = NumPages - HandleEntry->PageCount;
}
CurrentIndex = RunStart + RunSize;
HandleEntry->PageCount += RunSize;
RtlSetBits(&AllocBitmap, RunStart, RunSize);
for (i = 0; i < RunSize; i++)
{
PageTable[RunStart + i].Handle = *Handle;
InsertTailList(&HandleEntry->PageList, &PageTable[RunStart + i].Entry);
}
}
return EMS_STATUS_SUCCESS;
}
mitk::BoundingShapeVtkMapper2D::LocalStorage::LocalStorage()
: m_Actor(vtkSmartPointer<vtkActor>::New()),
m_HandleActor(vtkSmartPointer<vtkActor2D>::New()),
m_SelectedHandleActor(vtkSmartPointer<vtkActor2D>::New()),
m_Mapper(vtkSmartPointer<vtkPolyDataMapper>::New()),
m_HandleMapper(vtkSmartPointer<vtkPolyDataMapper2D>::New()),
m_SelectedHandleMapper(vtkSmartPointer<vtkPolyDataMapper2D>::New()),
m_Cutter(vtkSmartPointer<vtkCutter>::New()),
m_CuttingPlane(vtkSmartPointer<vtkPlane>::New()),
m_LastSliceNumber(0),
m_PropAssembly(vtkSmartPointer<vtkPropAssembly>::New()),
m_ZoomFactor(1.0)
{
m_Actor->SetMapper(m_Mapper);
m_Actor->GetProperty()->SetOpacity(0.3);
m_Actor->VisibilityOn();
m_HandleActor->SetMapper(m_HandleMapper);
m_HandleActor->VisibilityOn();
m_SelectedHandleActor->VisibilityOn();
m_SelectedHandleActor->GetProperty()->SetColor(0, 1.0, 0);
m_SelectedHandleActor->SetMapper(m_SelectedHandleMapper);
vtkCoordinate *tcoord = vtkCoordinate::New();
tcoord->SetCoordinateSystemToWorld();
m_SelectedHandleMapper->SetTransformCoordinate(tcoord);
tcoord->Delete();
m_Cutter->SetCutFunction(m_CuttingPlane);
for (int i = 0; i < 6; ++i)
m_Handles.push_back(CreateHandle());
m_PropAssembly->AddPart(m_Actor);
m_PropAssembly->AddPart(m_HandleActor);
m_PropAssembly->VisibilityOn();
}
void Collider3D::ForEachPolygon(const std::function<void(const Vector3f* vertices, std::size_t vertexCount)>& callback) const
{
auto newtCallback = [](void* const userData, int vertexCount, const dFloat* const faceArray, int /*faceId*/)
{
static_assert(sizeof(Vector3f) == 3 * sizeof(float), "Vector3 is expected to contain 3 floats without padding");
const auto& cb = *static_cast<std::add_pointer_t<decltype(callback)>>(userData);
cb(reinterpret_cast<const Vector3f*>(faceArray), vertexCount);
};
// Check for existing collision handles, and create a temporary one if none is available
if (m_handles.empty())
{
PhysWorld3D world;
NewtonCollision* collision = CreateHandle(&world);
{
NewtonCollisionForEachPolygonDo(collision, Nz::Matrix4f::Identity(), newtCallback, const_cast<void*>(static_cast<const void*>(&callback))); //< This isn't that bad; pointer will not be used for writing
}
NewtonDestroyCollision(collision);
}
else
NewtonCollisionForEachPolygonDo(m_handles.begin()->second, Nz::Matrix4f::Identity(), newtCallback, const_cast<void*>(static_cast<const void*>(&callback))); //< This isn't that bad; pointer will not be used for writing
}
/***************************************************************************\
* DdeConnectList (DDEML API)
*
* Description:
* Initiates DDE conversations with multiple servers or adds unique servers
* to an existing conversation list.
*
* History:
* 11-12-91 sanfords Created.
\***************************************************************************/
HCONVLIST DdeConnectList(
DWORD idInst,
HSZ hszService,
HSZ hszTopic,
HCONVLIST hConvList,
PCONVCONTEXT pCC)
{
PCL_INSTANCE_INFO pcii;
PCONV_INFO pcoi, pcoiNew, pcoiExisting, pcoiNext;
HCONVLIST hConvListRet = 0;
HWND hwndTarget = 0;
LATOM aNormalSvcName = 0;
PCONVLIST pcl = NULL;
HCONVLIST hConvListOld;
int i;
CheckDDECritOut;
EnterDDECrit;
if (!ValidateConnectParameters((HANDLE)idInst, &pcii, &hszService, hszTopic,
&aNormalSvcName, &pCC, &hwndTarget, hConvList)) {
goto Exit;
}
ValidateConvList(hConvList);
hConvListOld = hConvList;
pcoi = (PCONV_INFO)ConnectConv(pcii,
LATOM_FROM_HSZ(hszService),
LATOM_FROM_HSZ(hszTopic),
hwndTarget,
(pcii->afCmd & (CBF_FAIL_SELFCONNECTIONS | CBF_FAIL_CONNECTIONS)) ?
pcii->hwndMother : 0,
pCC,
hConvListOld,
CLST_MULT_INITIALIZING);
if (pcoi == NULL) {
/*
* no new connections made
*/
SetLastDDEMLError(pcii, DMLERR_NO_CONV_ESTABLISHED);
hConvListRet = hConvListOld;
goto Exit;
}
/*
* allocate or reallocate the hConvList hwnd list for later addition
* If we already have a valid list, reuse the handle so we don't have
* to alter the preexisting pcoi->hConvList values.
*/
if (hConvListOld == 0) {
pcl = (PCONVLIST)DDEMLAlloc(sizeof(CONVLIST));
if (pcl == NULL) {
SetLastDDEMLError(pcii, DMLERR_MEMORY_ERROR);
DisconnectConv(pcoi);
goto Exit;
}
// pcl->chwnd = 0; LPTR zero inits.
hConvList = (HCONVLIST)CreateHandle((DWORD)pcl,
HTYPE_CONVERSATION_LIST, InstFromHandle(pcii->hInstClient));
if (hConvList == 0) {
DDEMLFree(pcl);
SetLastDDEMLError(pcii, DMLERR_MEMORY_ERROR);
DisconnectConv(pcoi);
goto Exit;
}
} else {
pcl = (PCONVLIST)GetHandleData((HANDLE)hConvList);
pcl = DDEMLReAlloc(pcl, sizeof(CONVLIST) + sizeof(HWND) * pcl->chwnd);
if (pcl == NULL) {
SetLastDDEMLError(pcii, DMLERR_MEMORY_ERROR);
hConvListRet = hConvListOld;
DisconnectConv(pcoi);
goto Exit;
}
SetHandleData((HANDLE)hConvList, (DWORD)pcl);
}
ValidateConvList(hConvListOld);
if (hConvListOld) {
/*
* remove duplicates from new conversations
*
* Although we tried to prevent duplicates from happening
* within the initiate enumeration code, wild initiates or
* servers responding with different service names than
* requested could cause duplicates.
*/
/* For each client window... */
for (i = 0; i < pcl->chwnd; i++) {
/* For each existing conversation in that window... */
for (pcoiExisting = (PCONV_INFO)
GetWindowLong(pcl->ahwnd[i], GWL_PCI);
pcoi != NULL && pcoiExisting != NULL;
pcoiExisting = pcoiExisting->next) {
if (!(pcoiExisting->state & ST_CONNECTED))
continue;
/* For each new conversation... */
for (pcoiNew = pcoi; pcoiNew != NULL; pcoiNew = pcoiNext) {
pcoiNext = pcoiNew->next;
/* see if the new conversation duplicates the existing one */
if (!(pcoiNew->state & ST_CONNECTED))
continue;
UserAssert(((PCL_CONV_INFO)pcoiExisting)->hwndReconnect);
UserAssert(((PCL_CONV_INFO)pcoiNew)->hwndReconnect);
if (((PCL_CONV_INFO)pcoiExisting)->hwndReconnect ==
((PCL_CONV_INFO)pcoiNew)->hwndReconnect &&
pcoiExisting->laTopic == pcoiNew->laTopic &&
pcoiExisting->laService == pcoiNew->laService) {
/*
* duplicate conversation - disconnection causes an unlink
*/
if (pcoiNew == pcoi) {
/*
* We are freeing up the head of the list,
* Reset the head to the next guy.
*/
pcoi = pcoiNext;
}
ValidateConvList(hConvList);
ShutdownConversation(pcoiNew, FALSE);
ValidateConvList(hConvList);
break;
}
}
}
}
for (pcoiExisting = pcoi; pcoiExisting != NULL; pcoiExisting = pcoiExisting->next) {
/*
* if these are all zombies - we DONT want to link it in!
* This is possible because ShutdownConversation() leaves the critical section
* and could allow responding terminates to come through.
*/
if (pcoiExisting->state & ST_CONNECTED) {
goto FoundOne;
}
}
pcoi = NULL; // abandon this guy - he will clean up in time.
FoundOne:
/*
* add new pcoi (if any are left) hwnd to ConvList hwnd list.
*/
if (pcoi != NULL) {
UserAssert(pcoi->hwndConv);
pcl->ahwnd[pcl->chwnd] = pcoi->hwndConv;
pcl->chwnd++;
hConvListRet = hConvList;
} else {
hConvListRet = hConvListOld;
if (!hConvListOld) {
DestroyHandle((HANDLE)hConvList);
}
}
} else { // no hConvListOld
UserAssert(pcoi->hwndConv);
pcl->ahwnd[0] = pcoi->hwndConv;
pcl->chwnd = 1;
hConvListRet = hConvList;
}
if (pcoi != NULL) {
/*
* set hConvList field for all remaining new conversations.
*/
UserAssert(hConvListRet);
for (pcoiNew = pcoi; pcoiNew != NULL; pcoiNew = pcoiNew->next) {
if (pcoiNew->state & ST_CONNECTED) {
((PCL_CONV_INFO)pcoiNew)->hConvList = hConvListRet;
}
}
}
Exit:
if (aNormalSvcName) {
DeleteAtom(aNormalSvcName);
}
ValidateConvList(hConvListRet);
LeaveDDECrit;
return (hConvListRet);
}
FAudioDevice* FAudioDeviceManager::CreateAudioDevice(uint32& HandleOut, bool bCreateNewDevice)
{
// If we don't have an audio device module, then we can't create new audio devices.
if (AudioDeviceModule == nullptr)
{
HandleOut = AUDIO_DEVICE_HANDLE_INVALID;
return nullptr;
}
// If we are running without the editor, we only need one audio device.
if (!GIsEditor)
{
if (NumActiveAudioDevices == 1)
{
FAudioDevice* MainAudioDevice = GEngine->GetMainAudioDevice();
if (MainAudioDevice)
{
HandleOut = MainAudioDevice->DeviceHandle;
return MainAudioDevice;
}
return nullptr;
}
}
FAudioDevice* NewAudioDevice = nullptr;
if (NumActiveAudioDevices < AUDIO_DEVICE_DEFAULT_ALLOWED_DEVICE_COUNT || (bCreateNewDevice && NumActiveAudioDevices < AUDIO_DEVICE_MAX_DEVICE_COUNT))
{
// Create the new audio device and make sure it succeeded
NewAudioDevice = AudioDeviceModule->CreateAudioDevice();
if (NewAudioDevice == nullptr)
{
HandleOut = AUDIO_DEVICE_HANDLE_INVALID;
return nullptr;
}
// Now generation a new audio device handle for the device and store the
// ptr to the new device in the array of audio devices.
uint32 AudioDeviceIndex(AUDIO_DEVICE_HANDLE_INVALID);
// First check to see if we should start recycling audio device indices, if not
// then we add a new entry to the Generation array and generate a new index
if (FreeIndicesSize > AUDIO_DEVICE_MINIMUM_FREE_AUDIO_DEVICE_INDICES)
{
FreeIndices.Dequeue(AudioDeviceIndex);
--FreeIndicesSize;
check(int32(AudioDeviceIndex) < Devices.Num());
check(Devices[AudioDeviceIndex] == nullptr);
Devices[AudioDeviceIndex] = NewAudioDevice;
}
else
{
// Add a zeroth generation entry in the Generation array, get a brand new
// index and append the created device to the end of the Devices array
Generations.Add(0);
AudioDeviceIndex = Generations.Num() - 1;
check(AudioDeviceIndex < (1 << AUDIO_DEVICE_HANDLE_INDEX_BITS));
Devices.Add(NewAudioDevice);
}
HandleOut = CreateHandle(AudioDeviceIndex, Generations[AudioDeviceIndex]);
// Store the handle on the audio device itself
NewAudioDevice->DeviceHandle = HandleOut;
}
else
{
++NumWorldsUsingMainAudioDevice;
FAudioDevice* MainAudioDevice = GEngine->GetMainAudioDevice();
if (MainAudioDevice)
{
HandleOut = MainAudioDevice->DeviceHandle;
NewAudioDevice = MainAudioDevice;
}
}
++NumActiveAudioDevices;
return NewAudioDevice;
}
THandle OsNetworkCreate(OsContext* aContext, OsNetworkSocketType aSocketType)
{
SOCKET socketH = socket(AF_INET, aSocketType, 0);
OsNetworkHandle* handle = CreateHandle(aContext, socketH);
return (THandle)handle;
}
/***************************************************************************\
* FreeConversationResources
*
* Description:
* Used when: Client window is disconnected by app, Server window is
* disconnected by either side, or when a conversation is disconnected
* at Uninitialize time.
*
* This function releases all resources held by the pcoi and unlinks it
* from its host window pcoi chian. pcoi is freed once this return s.
*
* History:
* 12-21-91 sanfords Created.
\***************************************************************************/
VOID FreeConversationResources(
PCONV_INFO pcoi)
{
PADVISE_LINK paLink;
PDDE_MESSAGE_QUEUE pdmq;
PXACT_INFO pxi;
CheckDDECritIn;
/*
* Don't free resources on locked conversations.
*/
if (pcoi->cLocks > 0) {
pcoi->state |= ST_FREE_CONV_RES_NOW;
return;
}
/*
* Don't free resources if a synchronous transaction is in effect!
*/
pxi = pcoi->pxiOut;
while (pxi != NULL) {
if (pxi->flags & XIF_SYNCHRONOUS) {
/*
* This conversation is in a synchronous transaction.
* Shutdown the modal loop FIRST, then call this when
* the loop exits.
*/
PostMessage(pcoi->hwndConv, WM_TIMER, TID_TIMEOUT, 0);
pcoi->state |= ST_FREE_CONV_RES_NOW;
return;
}
pxi = pxi->next;
}
/*
* If this is an Intra-Process conversation that hasn't yet received
* a terminate message, make it a zombie. We will call this routine
* again once the terminate arrives or when WaitForZombieTerminate() has
* timed out waiting.
*/
if (pcoi->state & ST_INTRA_PROCESS && !(pcoi->state & ST_TERMINATE_RECEIVED)) {
DestroyHandle((HANDLE)pcoi->hConv);
pcoi->hConv = (HCONV)CreateHandle((DWORD)pcoi, HTYPE_ZOMBIE_CONVERSATION,
InstFromHandle(pcoi->hConv));
UnlinkConvFromOthers(pcoi, TRUE);
return;
}
/*
* remove any transactions left in progress
*/
while (pcoi->pxiOut != NULL) {
(pcoi->pxiOut->pfnResponse)(pcoi->pxiOut, 0, 0);
}
/*
* Throw away any incomming queued DDE messages.
*/
while (pcoi->dmqOut != NULL) {
pdmq = pcoi->dmqOut;
DumpDDEMessage(!(pcoi->state & ST_INTRA_PROCESS), pdmq->msg, pdmq->lParam);
pcoi->dmqOut = pcoi->dmqOut->next;
if (pcoi->dmqOut == NULL) {
pcoi->dmqIn = NULL;
}
DDEMLFree(pdmq);
}
//
// Remove all link info
//
paLink = pcoi->aLinks;
while (pcoi->cLinks) {
if (pcoi->state & ST_CLIENT) {
MONLINK(pcoi->pcii, FALSE, paLink->wType & XTYPF_NODATA,
pcoi->laService, pcoi->laTopic,
LocalToGlobalAtom(paLink->laItem),
paLink->wFmt, FALSE,
(HCONV)pcoi->hwndPartner, (HCONV)pcoi->hwndConv);
} else {
MONLINK(pcoi->pcii, FALSE, paLink->wType & XTYPF_NODATA,
pcoi->laService, pcoi->laTopic,
LocalToGlobalAtom(paLink->laItem),
paLink->wFmt, TRUE,
(HCONV)pcoi->hwndConv, (HCONV)pcoi->hwndPartner);
}
if (!(pcoi->state & ST_CLIENT)) {
DeleteLinkCount(pcoi->pcii, paLink->pLinkCount);
}
DeleteAtom(paLink->laItem); // link structure copy
paLink++;
pcoi->cLinks--;
}
if (pcoi->aLinks) {
DDEMLFree(pcoi->aLinks);
}
//
// free atoms associated with this conv
//
DeleteAtom(pcoi->laService);
DeleteAtom(pcoi->laTopic);
if (pcoi->laServiceRequested) {
DeleteAtom(pcoi->laServiceRequested);
}
UnlinkConvFromOthers(pcoi, FALSE);
/*
* invalidate app's conversation handle
*/
DestroyHandle((HANDLE)pcoi->hConv);
DDEMLFree(pcoi);
}
