static rdpChannels* freerdp_channels_find_by_instance(freerdp* instance)
{
int index;
BOOL found = FALSE;
rdpChannels* channels = NULL;
ArrayList_Lock(g_ChannelsList);
index = 0;
channels = (rdpChannels*) ArrayList_GetItem(g_ChannelsList, index++);
while (channels)
{
if (channels->instance == instance)
{
found = TRUE;
break;
}
channels = (rdpChannels*) ArrayList_GetItem(g_ChannelsList, index++);
}
ArrayList_Unlock(g_ChannelsList);
return (found) ? channels : NULL;
}
IWTSVirtualChannel *dvcman_find_channel_by_id(IWTSVirtualChannelManager *pChannelMgr, UINT32 ChannelId)
{
int index;
BOOL found = FALSE;
DVCMAN_CHANNEL *channel;
DVCMAN *dvcman = (DVCMAN *) pChannelMgr;
assert(dvcman);
ArrayList_Lock(dvcman->channels);
index = 0;
channel = (DVCMAN_CHANNEL *) ArrayList_GetItem(dvcman->channels, index++);
while (channel)
{
if (channel->channel_id == ChannelId)
{
found = TRUE;
break;
}
channel = (DVCMAN_CHANNEL *) ArrayList_GetItem(dvcman->channels, index++);
}
ArrayList_Unlock(dvcman->channels);
return (found) ? ((IWTSVirtualChannel *) channel) : NULL;
}
int SortedLimitedList_AddItem (SortedLimitedList* self, void* value)
{
int pos = ArrayList_Count(&self->base);
while (pos > 0 && self->comparator.compareTo(&self->comparator, ArrayList_GetItem(&self->base, pos-1), value) >= 0) {
if (pos < self->max) {
if (pos==self->max-1) {
if (ArrayList_Count(&self->base) == self->max) {
if (self->deletefn) {
self->deletefn(ArrayList_GetItem(&self->base, pos));
}
}
}
SortedLimitedList_SetItem(self, pos, ArrayList_GetItem(&self->base, pos-1));
}
pos --;
}
if (pos < self->max) {
if (pos==self->max-1) {
if (ArrayList_Count(&self->base) == self->max) {
if (self->deletefn) {
self->deletefn(ArrayList_GetItem(&self->base, pos));
}
}
}
SortedLimitedList_SetItem(self, pos, value);
} else {
if (self->deletefn) {
self->deletefn(value);
}
pos = -1;
}
return pos;
}
int main (int argc, char* argv[])
{
ArrayList* al = ArrayList_new0 (FilterPoint_delete);
Random* rnd = Random_new0 ();
int n;
for (n = 0 ; n < 10 ; ++n) {
FilterPoint* p = FilterPoint_new0 ();
p->x = Random_NextDouble(rnd) * 400.0;
p->y = Random_NextDouble(rnd) * 400.0;
ArrayList_AddItem(al, p);
}
int i;
for(i=0; i<ArrayList_Count(al); i++) {
FilterPoint* p = ArrayList_GetItem(al, i);
WriteLine ("%f %f # GNUPLOT1", p->x, p->y);
}
AreaFilter* conv = AreaFilter_new0 ();
ArrayList* hull = AreaFilter_CreateConvexHull(conv, al);
WriteLine ("\nhull: %d elements", ArrayList_Count(hull));
int j;
for(j=0; j<ArrayList_Count(hull); j++) {
FilterPoint* p = ArrayList_GetItem(hull, j);
WriteLine ("%f %f # GNUPLOT2", p->x, p->y);
}
WriteLine ("\npolygon area: %f", AreaFilter_PolygonArea(conv, hull));
ArrayList_delete(al);
return 0;
}
ArrayList* MatchKeys_FilterJoins (ArrayList* matches)
{
HashTable* ht = HashTable_new0 (NULL, NULL);
// Count the references to each keypoint
int i;
for(i=0; i<ArrayList_Count(matches); i++) {
Match* m = (Match*) ArrayList_GetItem(matches, i);
int lI = (HashTable_GetItem(ht, m->kp1) == NULL) ? 0 : (int) HashTable_GetItem(ht, m->kp1);
HashTable_SetItem(ht, m->kp1, (void*)(lI + 1));
int rI = (HashTable_GetItem(ht, m->kp2) == NULL) ? 0 : (int) HashTable_GetItem(ht, m->kp2);
HashTable_SetItem(ht, m->kp2, (void*)(rI + 1));
}
ArrayList* survivors = ArrayList_new0(NULL);
int removed = 0;
int j;
for(j=0; j<ArrayList_Count(matches); j++) {
Match* m = (Match*) ArrayList_GetItem(matches, j);
//WriteLine ("match: %d, %d", (int) HashTable_GetItem(ht, m->kp1), (int) HashTable_GetItem(ht, m->kp2));
if (((int) HashTable_GetItem(ht, m->kp1)) <= 1 && ((int) HashTable_GetItem(ht, m->kp2)) <= 1)
ArrayList_AddItem(survivors, m);
else
removed += 1;
}
HashTable_delete(ht);
return (survivors);
}
static rdpChannels* freerdp_channels_find_by_open_handle(int open_handle, int* pindex)
{
int i, j;
BOOL found = FALSE;
rdpChannels* channels = NULL;
ArrayList_Lock(g_ChannelsList);
i = j = 0;
channels = (rdpChannels*) ArrayList_GetItem(g_ChannelsList, i++);
while (channels)
{
for (j = 0; j < channels->channelDataCount; j++)
{
if (channels->channelDataList[j].open_handle == open_handle)
{
*pindex = j;
found = TRUE;
break;
}
}
if (found)
break;
channels = (rdpChannels*) ArrayList_GetItem(g_ChannelsList, i++);
}
ArrayList_Unlock(g_ChannelsList);
return (found) ? channels : NULL;
}
static rdpSvcPlugin* svc_plugin_find_by_open_handle(UINT32 open_handle)
{
int index;
BOOL found = FALSE;
rdpSvcPlugin* plugin;
ArrayList_Lock(g_AddinList);
index = 0;
plugin = (rdpSvcPlugin*) ArrayList_GetItem(g_AddinList, index++);
while (plugin)
{
if (plugin->open_handle == open_handle)
{
found = TRUE;
break;
}
plugin = (rdpSvcPlugin*) ArrayList_GetItem(g_AddinList, index++);
}
ArrayList_Unlock(g_AddinList);
return (found) ? plugin : NULL;
}
VOID WINAPI FreeRDP_WTSCloseServer(HANDLE hServer)
{
int index;
int count;
rdpPeerChannel* channel;
WTSVirtualChannelManager* vcm;
vcm = (WTSVirtualChannelManager*) hServer;
if (vcm)
{
HashTable_Remove(g_ServerHandles, (void*)(UINT_PTR) vcm->SessionId);
ArrayList_Lock(vcm->dynamicVirtualChannels);
count = ArrayList_Count(vcm->dynamicVirtualChannels);
for (index = 0; index < count; index++)
{
channel = (rdpPeerChannel*) ArrayList_GetItem(vcm->dynamicVirtualChannels,
index);
WTSVirtualChannelClose(channel);
}
ArrayList_Unlock(vcm->dynamicVirtualChannels);
ArrayList_Free(vcm->dynamicVirtualChannels);
if (vcm->drdynvc_channel)
{
WTSVirtualChannelClose(vcm->drdynvc_channel);
vcm->drdynvc_channel = NULL;
}
MessageQueue_Free(vcm->queue);
free(vcm);
}
}
static void _Publish(rdpShadowMultiClientEvent* event)
{
wArrayList* subscribers;
struct rdp_shadow_multiclient_subscriber* subscriber = NULL;
int i;
subscribers = event->subscribers;
assert(event->consuming == 0);
/* Count subscribing clients */
ArrayList_Lock(subscribers);
for (i = 0; i < ArrayList_Count(subscribers); i++)
{
subscriber = (struct rdp_shadow_multiclient_subscriber *)ArrayList_GetItem(subscribers, i);
/* Set flag to subscriber: I acknowledge and please handle */
subscriber->pleaseHandle = TRUE;
event->consuming++;
}
ArrayList_Unlock(subscribers);
if (event->consuming > 0)
{
event->eventid = (event->eventid & 0xff) + 1;
WLog_VRB(TAG, "Server published event %d. %d clients.\n", event->eventid, event->consuming);
ResetEvent(event->doneEvent);
SetEvent(event->event);
}
return;
}
// Measure the absolute area of a non self-intersecting polygon.
// Formula by Paul Bourke
// (http://astronomy.swin.edu.au/~pbourke/geometry/polyarea/)
//
// The input points must be ordered (clock- or counter-clockwise). The
// polygon is closed automatically between the first and the last point,
// so there should not be two same points in the polygon point set.
double AreaFilter_PolygonArea (AreaFilter* self, ArrayList* orderedPoints)
{
double A = 0.0;
int n;
for (n = 0 ; n < ArrayList_Count(orderedPoints) ; ++n) {
FilterPoint* p0 = (FilterPoint*) ArrayList_GetItem(orderedPoints,n);
FilterPoint* p1 = (FilterPoint*) ArrayList_GetItem(orderedPoints, (n + 1) % ArrayList_Count(orderedPoints));
A += p0->x * p1->y - p1->x * p0->y;
}
A *= 0.5;
return (abs (A));
}
WNDCLASSEXA* FindWindowClass(LPCSTR lpClassName)
{
int index;
int count;
BOOL found = FALSE;
WNDCLASSEXA* lpwcx = NULL;
ArrayList_Lock(g_WindowClasses);
count = ArrayList_Count(g_WindowClasses);
for (index = 0; index < count; index++)
{
lpwcx = (WNDCLASSEXA*) ArrayList_GetItem(g_WindowClasses, index);
if (strcmp(lpClassName, lpwcx->lpszClassName) == 0)
{
found = TRUE;
break;
}
}
ArrayList_Unlock(g_WindowClasses);
return (found) ? lpwcx : NULL;
}
static rdpPeerChannel* wts_get_dvc_channel_by_id(WTSVirtualChannelManager* vcm, UINT32 ChannelId)
{
int index;
int count;
BOOL found = FALSE;
rdpPeerChannel* channel = NULL;
ArrayList_Lock(vcm->dynamicVirtualChannels);
count = ArrayList_Count(vcm->dynamicVirtualChannels);
for (index = 0; index < count; index++)
{
channel = (rdpPeerChannel*) ArrayList_GetItem(vcm->dynamicVirtualChannels, index);
if (channel->channelId == ChannelId)
{
found = TRUE;
break;
}
}
ArrayList_Unlock(vcm->dynamicVirtualChannels);
return found ? channel : NULL;
}
int shadow_client_boardcast_msg(rdpShadowServer* server, void* context, UINT32 type, SHADOW_MSG_OUT* msg, void* lParam)
{
wMessage message = {0};
rdpShadowClient* client = NULL;
int count = 0;
int index = 0;
message.context = context;
message.id = type;
message.wParam = (void *)msg;
message.lParam = lParam;
message.Free = shadow_msg_out_release;
/* First add reference as we reference it in this function.
* Therefore it would not be free'ed during post. */
shadow_msg_out_addref(&message);
ArrayList_Lock(server->clients);
for (index = 0; index < ArrayList_Count(server->clients); index++)
{
client = (rdpShadowClient*)ArrayList_GetItem(server->clients, index);
if (shadow_client_dispatch_msg(client, &message))
{
count++;
}
}
ArrayList_Unlock(server->clients);
/* Release the reference for this function */
shadow_msg_out_release(&message);
return count;
}
TSMF_PRESENTATION* tsmf_presentation_find_by_id(const BYTE *guid)
{
UINT32 index;
UINT32 count;
BOOL found = FALSE;
char guid_str[GUID_SIZE * 2 + 1];
TSMF_PRESENTATION* presentation;
ArrayList_Lock(presentation_list);
count = ArrayList_Count(presentation_list);
for (index = 0; index < count; index++)
{
presentation = (TSMF_PRESENTATION*) ArrayList_GetItem(presentation_list, index);
if (memcmp(presentation->presentation_id, guid, GUID_SIZE) == 0)
{
found = TRUE;
break;
}
}
ArrayList_Unlock(presentation_list);
if (!found)
WLog_WARN(TAG, "presentation id %s not found", guid_to_string(guid, guid_str, sizeof(guid_str)));
return (found) ? presentation : NULL;
}
bool AreaFilter_ccw (ArrayList* points, int i, int j, int k)
{
double a = ((FilterPoint*)ArrayList_GetItem(points, i))->x - ((FilterPoint*)ArrayList_GetItem(points, j))->x;
double b = ((FilterPoint*)ArrayList_GetItem(points, i))->y - ((FilterPoint*)ArrayList_GetItem(points, j))->y;
double c = ((FilterPoint*)ArrayList_GetItem(points, k))->x - ((FilterPoint*)ArrayList_GetItem(points, j))->x;
double d = ((FilterPoint*)ArrayList_GetItem(points, k))->y - ((FilterPoint*)ArrayList_GetItem(points, j))->y;
return ((a * d - b * c) <= 0.0);
}
BOOL tsmf_presentation_set_geometry_info(TSMF_PRESENTATION* presentation,
UINT32 x, UINT32 y, UINT32 width, UINT32 height, int num_rects, RDP_RECT *rects)
{
UINT32 index;
UINT32 count;
TSMF_STREAM* stream;
void *tmp_rects = NULL;
BOOL ret = TRUE;
/* The server may send messages with invalid width / height.
* Ignore those messages. */
if (!width || !height)
return TRUE;
/* Streams can be added/removed from the presentation and the server will resend geometry info when a new stream is
* added to the presentation. Also, num_rects is used to indicate whether or not the window is visible.
* So, always process a valid message with unchanged position/size and/or no visibility rects.
*/
presentation->x = x;
presentation->y = y;
presentation->width = width;
presentation->height = height;
tmp_rects = realloc(presentation->rects, sizeof(RDP_RECT) * num_rects);
if(!num_rects)
presentation->rects=NULL;
if (!tmp_rects&&num_rects)
return;
presentation->nr_rects = num_rects;
presentation->rects = tmp_rects;
CopyMemory(presentation->rects, rects, sizeof(RDP_RECT) * num_rects);
ArrayList_Lock(presentation->stream_list);
count = ArrayList_Count(presentation->stream_list);
for (index = 0; index < count; index++)
{
stream = (TSMF_STREAM *) ArrayList_GetItem(presentation->stream_list, index);
if (!stream->decoder)
continue;
if (stream->decoder->UpdateRenderingArea)
{
ret = stream->decoder->UpdateRenderingArea(stream->decoder, x, y, width, height, num_rects, rects);
}
}
ArrayList_Unlock(presentation->stream_list);
return ret;
}
BOOL tsmf_presentation_set_geometry_info(TSMF_PRESENTATION* presentation,
UINT32 x, UINT32 y, UINT32 width, UINT32 height, int num_rects, RDP_RECT *rects)
{
UINT32 index;
UINT32 count;
TSMF_STREAM* stream;
void *tmp_rects;
BOOL ret = TRUE;
if (num_rects < 1 || !rects)
return TRUE;
/* The server may send messages with invalid width / height.
* Ignore those messages. */
if (!width || !height)
return TRUE;
if ((width == presentation->width) && (height == presentation->height) &&
(x == presentation->x) && (y == presentation->y) &&
(num_rects == presentation->nr_rects) &&
(0 == memcmp(rects, presentation->rects, num_rects * sizeof(RDP_RECT))))
{
return TRUE;
}
presentation->x = x;
presentation->y = y;
presentation->width = width;
presentation->height = height;
tmp_rects = realloc(presentation->rects, sizeof(RDP_RECT) * num_rects);
if (!tmp_rects)
return FALSE;
presentation->nr_rects = num_rects;
presentation->rects = tmp_rects;
CopyMemory(presentation->rects, rects, sizeof(RDP_RECT) * num_rects);
ArrayList_Lock(presentation->stream_list);
count = ArrayList_Count(presentation->stream_list);
for (index = 0; index < count; index++)
{
stream = (TSMF_STREAM *) ArrayList_GetItem(presentation->stream_list, index);
if (!stream->decoder)
continue;
if (stream->decoder->UpdateRenderingArea)
{
ret = stream->decoder->UpdateRenderingArea(stream->decoder, x, y, width, height, num_rects, rects);
}
}
ArrayList_Unlock(presentation->stream_list);
return ret;
}
// Create the convex hull of a point set.
ArrayList* AreaFilter_CreateConvexHull (AreaFilter* self, ArrayList* points)
{
int chn = AreaFilter_CreateHull (self, points);
ArrayList* hull = ArrayList_new0 (NULL);
int k;
for (k = 0 ; k < chn ; ++k)
ArrayList_AddItem(hull, ArrayList_GetItem (points, k));
return (hull);
}
ArrayList* MatchKeys_FindMatchesBBF (ArrayList* keys1, ArrayList* keys2)
{
// TODO: swap so smaller list is searched.
ArrayList* al = ArrayList_new0 (NULL);
int i;
for (i=0; i<ArrayList_Count(keys2); i++)
ArrayList_AddItem (al, ArrayList_GetItem(keys2, i));
KDTree* kd = KDTree_CreateKDTree (al);
ArrayList_delete(al);
ArrayList* matches = ArrayList_new0 (Match_delete);
int j;
for (j=0; j<ArrayList_Count(keys1); j++) {
KeypointN* kp = (KeypointN*) ArrayList_GetItem(keys1, j);
ArrayList* kpNNList = (ArrayList*)KDTree_NearestNeighbourListBBF (kd, (IKDTreeDomain*)kp, 2, 40);
if (ArrayList_Count(kpNNList) < 2)
FatalError ("BUG: less than two neighbours!");
KDTreeBestEntry* be1 = (KDTreeBestEntry*) ArrayList_GetItem(kpNNList, 0);
KDTreeBestEntry* be2 = (KDTreeBestEntry*) ArrayList_GetItem(kpNNList, 1);
if ((be1->distance / be2->distance) > 0.6)
continue;
KeypointN* kpN = (KeypointN*)KDTreeBestEntry_Neighbour(be1);
ArrayList_AddItem(matches, Match_new (kp, kpN, be1->distance, be2->distance));
/*
WriteLine ("(%d,%d) (%d,%d) %d, 2nd: %d", (int)(kp->x + 0.5),
(int)(kp->y + 0.5), (int)(kpN->x + 0.5),
(int)(kpN->y + 0.5), be1->distance, be2->distance);
*/
}
return (matches);
}
int xf_event_execute_action_script(xfContext* xfc, XEvent* event)
{
int index;
int count;
char* name;
int exitCode;
FILE* actionScript;
BOOL match = FALSE;
const char* xeventName;
char buffer[1024] = { 0 };
char command[1024] = { 0 };
if (!xfc->actionScript)
return 1;
if (event->type > (sizeof(X11_EVENT_STRINGS) / sizeof(const char*)))
return 1;
xeventName = X11_EVENT_STRINGS[event->type];
count = ArrayList_Count(xfc->xevents);
for (index = 0; index < count; index++)
{
name = (char*) ArrayList_GetItem(xfc->xevents, index);
if (_stricmp(name, xeventName) == 0)
{
match = TRUE;
break;
}
}
if (!match)
return 1;
sprintf_s(command, sizeof(command), "%s xevent %s %d",
xfc->actionScript, xeventName, (int) xfc->window->handle);
actionScript = popen(command, "r");
if (actionScript < 0)
return -1;
while (fgets(buffer, sizeof(buffer), actionScript))
{
strtok(buffer, "\n");
}
exitCode = pclose(actionScript);
return 1;
}
static BOOL xf_event_execute_action_script(xfContext* xfc, XEvent* event)
{
int index;
int count;
char* name;
FILE* actionScript;
BOOL match = FALSE;
const char* xeventName;
char buffer[1024] = { 0 };
char command[1024] = { 0 };
if (!xfc->actionScriptExists || !xfc->xevents)
return FALSE;
if (event->type > LASTEvent)
return FALSE;
xeventName = x11_event_string(event->type);
count = ArrayList_Count(xfc->xevents);
for (index = 0; index < count; index++)
{
name = (char*) ArrayList_GetItem(xfc->xevents, index);
if (_stricmp(name, xeventName) == 0)
{
match = TRUE;
break;
}
}
if (!match)
return FALSE;
sprintf_s(command, sizeof(command), "%s xevent %s %lu",
xfc->context.settings->ActionScript, xeventName, (unsigned long) xfc->window->handle);
actionScript = popen(command, "r");
if (!actionScript)
return FALSE;
while (fgets(buffer, sizeof(buffer), actionScript))
{
strtok(buffer, "\n");
}
pclose(actionScript);
return TRUE;
}
int AreaFilter_MakeChain (AreaFilter* self, ArrayList* points, int (*comp)(const FilterPoint*, const FilterPoint*))
{
IComparator comparator;
comparator.compareTo = (int ( *)(IComparator *,const void *,const void *)) comp;
ArrayList_Sort(points, &comparator);
int s = 1;
int pCount = ArrayList_Count(points);
int i;
for (i = 2 ; i < pCount ; ++i) {
int j;
for (j = s ; j >= 1 && AreaFilter_ccw (points, i, j, j - 1) ; --j)
;
s = j + 1;
// Swap
FilterPoint* t = (FilterPoint*) ArrayList_GetItem(points, s);
ArrayList_SetItem(points, s, ArrayList_GetItem(points, i));
ArrayList_SetItem(points, i, t);
}
return (s);
}
void tsmf_presentation_sync(TSMF_PRESENTATION* presentation)
{
UINT32 index;
UINT32 count;
ArrayList_Lock(presentation->stream_list);
count = ArrayList_Count(presentation->stream_list);
for (index = 0; index < count; index++)
{
TSMF_STREAM* stream = (TSMF_STREAM *) ArrayList_GetItem(presentation->stream_list, index);
WaitForSingleObject(stream->ready, 500);
}
ArrayList_Unlock(presentation->stream_list);
}
int AreaFilter_CreateHull (AreaFilter* self, ArrayList* points)
{
int u = AreaFilter_MakeChain (self, points, AreaFilter_CompareLow);
if (ArrayList_Count(points) == 0)
return (0);
/*
int k;
for (k = 0 ; k < u ; ++k)
WriteLine ("point %d: %f %f", k, ((FilterPoint*)ArrayList_GetItem(points, k)[k])->x,
((FilterPoint*)ArrayList_GetItem(points, k)[k])->y);
*/
ArrayList* pointsHigh = ArrayList_new(ArrayList_Count(points)+1-u, NULL);
//WriteLine ("points.Length = %d, u = %d", ArrayList_Count(points), u);
ArrayList_Copy (points, u, pointsHigh, 0, ArrayList_Count(points) - u);
ArrayList_SetItem(pointsHigh, ArrayList_Count(pointsHigh) - 1, ArrayList_GetItem(points, 0));
int h = AreaFilter_MakeChain (self, pointsHigh, AreaFilter_CompareHigh);
int p;
for ( p = u ; p < ArrayList_Count(points) ; ++p) {
ArrayList_SetItem(points, p, ArrayList_GetItem(pointsHigh, p-u));
}
/*
WriteLine ("h = %d, u = %d", h, u);
int k;
for (k = 0 ; k < (h + u) ; ++k)
WriteLine ("point %d: %f %f", k, ((FilterPoint*)ArrayList_GetItem(points, k)[k])->x,
((FilterPoint*)ArrayList_GetItem(points, k)[k])->y);
*/
return (h + u);
}
void tsmf_presentation_start(TSMF_PRESENTATION* presentation)
{
UINT32 index;
UINT32 count;
TSMF_STREAM* stream;
ArrayList_Lock(presentation->stream_list);
count = ArrayList_Count(presentation->stream_list);
for (index = 0; index < count; index++)
{
stream = (TSMF_STREAM *) ArrayList_GetItem(presentation->stream_list, index);
tsmf_stream_start(stream);
}
ArrayList_Unlock(presentation->stream_list);
}
void tsmf_presentation_volume_changed(TSMF_PRESENTATION* presentation, UINT32 newVolume, UINT32 muted)
{
UINT32 index;
UINT32 count;
TSMF_STREAM* stream;
presentation->volume = newVolume;
presentation->muted = muted;
ArrayList_Lock(presentation->stream_list);
count = ArrayList_Count(presentation->stream_list);
for (index = 0; index < count; index++)
{
stream = (TSMF_STREAM *) ArrayList_GetItem(presentation->stream_list, index);
tsmf_stream_change_volume(stream, newVolume, muted);
}
ArrayList_Unlock(presentation->stream_list);
}
BOOL tsmf_presentation_restarted(TSMF_PRESENTATION* presentation)
{
UINT32 index;
UINT32 count;
TSMF_STREAM* stream;
BOOL ret = TRUE;
ArrayList_Lock(presentation->stream_list);
count = ArrayList_Count(presentation->stream_list);
for (index = 0; index < count; index++)
{
stream = (TSMF_STREAM*) ArrayList_GetItem(presentation->stream_list, index);
ret &= tsmf_stream_restart(stream);
}
ArrayList_Unlock(presentation->stream_list);
return ret;
}
int shadow_client_boardcast_quit(rdpShadowServer* server, int nExitCode)
{
wMessageQueue* queue = NULL;
int count = 0;
int index = 0;
ArrayList_Lock(server->clients);
for (index = 0; index < ArrayList_Count(server->clients); index++)
{
queue = ((rdpShadowClient*)ArrayList_GetItem(server->clients, index))->MsgQueue;
if (MessageQueue_PostQuit(queue, nExitCode))
{
count++;
}
}
ArrayList_Unlock(server->clients);
return count;
}
RpcClientCall* rpc_client_call_find_by_id(rdpRpc* rpc, UINT32 CallId)
{
int index;
int count;
RpcClientCall* clientCall;
ArrayList_Lock(rpc->client->ClientCallList);
clientCall = NULL;
count = ArrayList_Count(rpc->client->ClientCallList);
for (index = 0; index < count; index++)
{
clientCall = (RpcClientCall*) ArrayList_GetItem(rpc->client->ClientCallList, index);
if (clientCall->CallId == CallId)
break;
}
ArrayList_Unlock(rpc->client->ClientCallList);
return clientCall;
}
ArrayList* MultiMatch_CreatePointList (MultiMatch* self, ArrayList* matches)
{
ArrayList* points = ArrayList_new0 (FilterPoint_delete);
// Create a point list.
int i;
for(i=0; i<ArrayList_Count(matches); i++) {
Match* m = (Match*) ArrayList_GetItem(matches, i);
FilterPoint* p = FilterPoint_new0 ();
p->x = m->kp1->x;
p->y = m->kp1->y;
p->user = m;
WriteLine ("%f %f # CPOINTS", p->x, p->y);
ArrayList_AddItem(points, p);
}
return (points);
}