void WxeApp::dispatch_cb(wxList * batch, wxList * temp, ErlDrvTermData process) {
int callback_returned = 0;
while(true) {
if (batch->size() > 0) {
for( wxList::compatibility_iterator node = batch->GetFirst();
node;
node = batch->GetFirst())
{
wxeCommand *event = (wxeCommand *)node->GetData();
wxeMemEnv *memenv = getMemEnv(event->port);
batch->Erase(node);
if(event->caller == process || // Callbacks from CB process only
event->op == WXE_CB_START || // Recursive event callback allow
// Allow connect_cb during CB i.e. msg from wxe_server.
(memenv && event->caller == memenv->owner))
{
switch(event->op) {
case WXE_BATCH_END:
case WXE_BATCH_BEGIN:
case WXE_DEBUG_PING:
break;
case WXE_CB_RETURN:
memcpy(cb_buff, event->buffer, event->len);
callback_returned = 1;
return;
case WXE_CB_START:
// CB start from now accept message from CB process only
process = event->caller;
break;
default:
erl_drv_mutex_unlock(wxe_batch_locker_m);
if(event->op < OPENGL_START) {
// fprintf(stderr, " cb %d \r\n", event->op);
wxe_dispatch(*event);
} else {
gl_dispatch(event->op,event->buffer,event->caller,event->bin);
}
erl_drv_mutex_lock(wxe_batch_locker_m);
break;
if(callback_returned)
return;
}
delete event;
} else {
// fprintf(stderr, " sav %d \r\n", event->op);
temp->Append(event);
}
}
} else {
if(callback_returned) {
return;
}
// sleep until something happens
//fprintf(stderr, "%s:%d sleep %d %d %d %d \r\n", __FILE__, __LINE__, batch->size(), callback_returned, blevel, is_callback);fflush(stderr);
while(batch->size() == 0) {
erl_drv_cond_wait(wxe_batch_locker_c, wxe_batch_locker_m);
}
}
}
}
// Should have erl_drv_mutex_lock(wxe_batch_locker_m);
// when entering this function and it should be released
// afterwards
int WxeApp::dispatch(wxList * batch, int blevel, int list_type)
{
int ping = 0;
// erl_drv_mutex_lock(wxe_batch_locker_m); must be locked already
while(true)
{
if (batch->size() > 0) {
for( wxList::compatibility_iterator node = batch->GetFirst();
node;
node = batch->GetFirst())
{
wxeCommand *event = (wxeCommand *)node->GetData();
batch->Erase(node);
switch(event->op) {
case WXE_BATCH_END:
{--blevel; }
break;
case WXE_BATCH_BEGIN:
{blevel++; }
break;
case WXE_DEBUG_PING:
// When in debugger we don't want to hang waiting for a BATCH_END
// that never comes, because a breakpoint have hit.
ping++;
if(ping > 2)
blevel = 0;
break;
case WXE_CB_RETURN:
// erl_drv_mutex_unlock(wxe_batch_locker_m); should be called after
// whatever cleaning is necessary
memcpy(cb_buff, event->buffer, event->len);
return blevel;
default:
erl_drv_mutex_unlock(wxe_batch_locker_m);
if(event->op < OPENGL_START) {
// fprintf(stderr, " c %d (%d) \r\n", event->op, blevel);
wxe_dispatch(*event);
} else {
gl_dispatch(event->op,event->buffer,event->caller,event->bin);
}
erl_drv_mutex_lock(wxe_batch_locker_m);
break;
}
delete event;
}
} else {
if((list_type == WXE_STORED) || (blevel <= 0 && list_type == WXE_NORMAL)) {
// erl_drv_mutex_unlock(wxe_batch_locker_m); should be called after
// whatever cleaning is necessary
return blevel;
}
// sleep until something happens
//fprintf(stderr, "%s:%d sleep %d %d %d %d \r\n", __FILE__, __LINE__, batch->size(), callback_returned, blevel, is_callback);fflush(stderr);
wxe_batch_caller++;
while(batch->size() == 0) {
erl_drv_cond_wait(wxe_batch_locker_c, wxe_batch_locker_m);
}
}
}
}
void WxeApp::dispatch_cmds()
{
if(wxe_status != WXE_INITIATED)
return;
recurse_level++;
int level = dispatch(wxe_queue_cb_saved, 0, WXE_STORED);
dispatch(wxe_queue, level, WXE_NORMAL);
recurse_level--;
// Cleanup old memenv's and deleted objects
if(recurse_level == 0) {
wxeCommand *curr;
while((curr = delayed_delete->Get()) != NULL) {
wxe_dispatch(*curr);
curr->Delete();
}
if(delayed_cleanup->size() > 0)
for( wxList::compatibility_iterator node = delayed_cleanup->GetFirst();
node;
node = delayed_cleanup->GetFirst()) {
wxeMetaCommand *event = (wxeMetaCommand *)node->GetData();
delayed_cleanup->Erase(node);
destroyMemEnv(*event);
delete event;
}
if(wxe_queue_cb_saved->m_old) {
driver_free(wxe_queue_cb_saved->m_old);
wxe_queue_cb_saved->m_old = NULL;
}
if(delayed_delete->m_old) {
driver_free(delayed_delete->m_old);
delayed_delete->m_old = NULL;
}
}
}
void WxeApp::dispatch_cb(wxeFifo * batch, wxeFifo * temp, ErlDrvTermData process) {
wxeCommand *event;
erl_drv_mutex_lock(wxe_batch_locker_m);
while(true) {
while((event = batch->Get()) != NULL) {
erl_drv_mutex_unlock(wxe_batch_locker_m);
wxeMemEnv *memenv = getMemEnv(event->port);
// fprintf(stderr, " Ev %d %lu\r\n", event->op, event->caller);
if(event->caller == process || // Callbacks from CB process only
event->op == WXE_CB_START || // Event callback start change process
event->op == WXE_CB_DIED || // Event callback process died
// Allow connect_cb during CB i.e. msg from wxe_server.
(memenv && event->caller == memenv->owner)) {
switch(event->op) {
case -1:
case WXE_BATCH_END:
case WXE_BATCH_BEGIN:
case WXE_DEBUG_PING:
break;
case WXE_CB_RETURN:
if(event->len > 0) {
cb_buff = (char *) driver_alloc(event->len);
memcpy(cb_buff, event->buffer, event->len);
} // continue
case WXE_CB_DIED:
event->Delete();
return;
case WXE_CB_START:
// CB start from now accept message from CB process only
process = event->caller;
break;
default:
size_t start=temp->m_n;
if(event->op < OPENGL_START) {
// fprintf(stderr, " cb %d \r\n", event->op);
wxe_dispatch(*event);
} else {
gl_dispatch(event->op,event->buffer,event->caller,event->bin);
}
if(temp->m_n > start) {
erl_drv_mutex_lock(wxe_batch_locker_m);
// We have recursed dispatch_cb and messages for this
// callback may be saved on temp list move them
// to orig list
for(unsigned int i=start; i < temp->m_n; i++) {
wxeCommand *ev = &temp->m_q[(temp->m_first+i) % temp->m_max];
if(ev->caller == process) {
batch->Append(ev);
}
}
erl_drv_mutex_unlock(wxe_batch_locker_m);
}
break;
}
event->Delete();
} else {
// fprintf(stderr, " save %d %lu\r\n", event->op, event->caller);
temp->Append(event);
}
erl_drv_mutex_lock(wxe_batch_locker_m);
}
// sleep until something happens
// fprintf(stderr, "%s:%d sleep %d %d\r\n", __FILE__, __LINE__,
// batch->m_n, temp->m_n);fflush(stderr);
wxe_needs_signal = 1;
while(batch->m_n == 0) {
erl_drv_cond_wait(wxe_batch_locker_c, wxe_batch_locker_m);
}
wxe_needs_signal = 0;
}
}
int WxeApp::dispatch(wxeFifo * batch, int blevel, int list_type)
{
int ping = 0;
wxeCommand *event;
if(list_type == WXE_NORMAL) erl_drv_mutex_lock(wxe_batch_locker_m);
while(true) {
while((event = batch->Get()) != NULL) {
if(list_type == WXE_NORMAL) erl_drv_mutex_unlock(wxe_batch_locker_m);
switch(event->op) {
case -1:
break;
case WXE_BATCH_END:
{--blevel; }
break;
case WXE_BATCH_BEGIN:
{blevel++; }
break;
case WXE_DEBUG_PING:
// When in debugger we don't want to hang waiting for a BATCH_END
// that never comes, because a breakpoint have hit.
ping++;
if(ping > 2)
blevel = 0;
break;
case WXE_CB_RETURN:
if(event->len > 0) {
cb_buff = (char *) driver_alloc(event->len);
memcpy(cb_buff, event->buffer, event->len);
}
event->Delete();
return blevel;
default:
if(event->op < OPENGL_START) {
// fprintf(stderr, " c %d (%d) \r\n", event->op, blevel);
wxe_dispatch(*event);
} else {
gl_dispatch(event->op,event->buffer,event->caller,event->bin);
}
break;
}
event->Delete();
if(list_type == WXE_NORMAL) erl_drv_mutex_lock(wxe_batch_locker_m);
}
if(list_type == WXE_STORED)
return blevel;
if(blevel <= 0) { // list_type == WXE_NORMAL
if(wxe_queue->m_old) {
driver_free(wxe_queue->m_old);
wxe_queue->m_old = NULL;
}
erl_drv_mutex_unlock(wxe_batch_locker_m);
return blevel;
}
// sleep until something happens
//fprintf(stderr, "%s:%d sleep %d %d\r\n", __FILE__, __LINE__, batch->m_n, blevel);fflush(stderr);
wxe_needs_signal = 1;
while(batch->m_n == 0) {
erl_drv_cond_wait(wxe_batch_locker_c, wxe_batch_locker_m);
}
wxe_needs_signal = 0;
}
}
