/*
* Command to control events when a cancel command is sent
*/
int onCancel( int argc, char *argv[], int retc, char *retv[] )
{
char msg[MAXPATH];
int yesNoOff;
if ( Bnmr )
RETURN;
if (argc == 1)
{
setCancel(1,"");
strcpy(msg,"");
}
else if (argc >= 2)
{
/* if true, do standard interrupt in addition to specific cancel command */
if ( (argc == 4) && ! strcmp(argv[3],"yes") )
yesNoOff = 1;
else if ( (argc == 4) && ! strcmp(argv[3],"off") )
yesNoOff = 2;
else
yesNoOff = 0;
if (argc >= 3)
setCancel(yesNoOff,argv[2]);
else
setCancel(yesNoOff,"");
strcpy(msg,argv[1]);
}
sendTripleEscToMaster( 'g',msg);
RETURN;
}
ADDDIALOG::ADDDIALOG(QWidget *parent) :
QDialog(parent),
ui(new Ui::ADDDIALOG)
{
setCancel (false);
ui->setupUi(this);
}
KeySignature::KeySignature(Staff* staff, int startTime, int accidentals, int cancel) : StaffElement(staff, startTime), d(new Private)
{
d->accidentalCount = 9999; // just some random illegal value
d->cancelCount = 9999;
setAccidentals(accidentals);
setCancel(cancel);
}
void Thread::close()
{
bool detached = isDetached();
#if !defined(CCXX_SIG_THREAD_ALARM) && !defined(__CYGWIN32__) && !defined(__MINGW32__) && !defined(WIN32)
if(this == PosixThread::_timer)
PosixThread::_arm.leaveMutex();
#endif
setCancel(cancelDisabled);
// if(_parent)
// _parent->notify(this);
// final can call destructor (that call Terminate)
final();
void Thread::exit(void)
{
if (isThread())
{
setCancel(cancelDisabled);
#ifdef WIN32
close();
ExitThread(0);
#else
pthread_exit(NULL);
#endif // WIN32
}
}
int Thread::start(Semaphore *st)
{
if(!priv)
return -1;
#ifdef WIN32
if(priv->_active)
return -1;
_start = st;
priv->_hThread = (HANDLE)_beginthreadex(NULL, (unsigned)priv->_stack, (exec_t)&Execute, (void *)this, CREATE_SUSPENDED, (unsigned *)&priv->_tid);
if(!priv->_hThread)
{
CloseHandle(priv->_cancellation);
priv->_cancellation = NULL;
return -1;
}
setCancel(cancelInitial);
SetThreadPriority(priv->_hThread, priv->_priority);
ResumeThread(priv->_hThread);
priv->_active = true;
return 0;
#else
if(priv->_tid)
{
if(_start)
{
_start->post();
return 0;
}
else
return -1;
}
_start = st;
return pthread_create(&priv->_tid, &priv->_attr, exec_t(&ccxx_exec_handler), this);
#endif
}
AudioRecorder::AudioRecorder (AudioRecord *arec, MainBuffer *mb) : Thread()
{
assert(mb);
setCancel (cancelDeferred);
++count;
std::string id ("processid_");
// convert count into string
std::string s;
std::stringstream out;
out << count;
s = out.str();
recorderId = id.append (s);
arecord = arec;
mbuffer = mb;
}
void ADDDIALOG::on_pushButtonCancel_clicked()
{
setCancel (true);
this->close ();
}
void SocketService::run(void)
{
timeout_t timer, expires;
SocketPort *port;
unsigned char buf;
#ifdef USE_POLL
Poller mfd;
pollfd * p_ufd;
int lastcount = 0;
// initialize ufd in all attached ports :
// probably don't need this but it can't hurt.
enterMutex();
port = first;
while(port)
{
port->ufd = 0;
port = port->next;
}
leaveMutex();
#else
struct timeval timeout, *tvp;
fd_set inp, out, err;
FD_ZERO(&inp);
FD_ZERO(&out);
FD_ZERO(&err);
int so;
#endif
setCancel(cancelDeferred);
for(;;)
{
timer = TIMEOUT_INF;
while(1 == ::read(iosync[0], (char *)&buf, 1))
{
if(buf)
{
onUpdate(buf);
continue;
}
setCancel(cancelImmediate);
sleep(TIMEOUT_INF);
exit();
}
#ifdef USE_POLL
bool reallocate = false;
MUTEX_START
onEvent();
port = first;
while(port)
{
onCallback(port);
if ( ( p_ufd = port->ufd ) ) {
if ( ( POLLHUP | POLLNVAL ) & p_ufd->revents ) {
// Avoid infinite loop from disconnected sockets
port->detect_disconnect = false;
p_ufd->events &= ~POLLHUP;
SocketPort* p = port;
port = port->next;
detach(p);
reallocate = true;
p->disconnect();
continue;
}
if ( ( POLLIN | POLLPRI ) & p_ufd->revents )
port->pending();
if ( POLLOUT & p_ufd->revents )
port->output();
} else {
reallocate = true;
}
retry:
expires = port->getTimer();
if(expires > 0)
if(expires < timer)
timer = expires;
if(!expires)
{
port->endTimer();
port->expired();
goto retry;
}
port = port->next;
}
//
// reallocate things if we saw a ServerPort without
// ufd set !
if ( reallocate || ( ( count + 1 ) != lastcount ) ) {
lastcount = count + 1;
p_ufd = mfd.getList( count + 1 );
// Set up iosync polling
p_ufd->fd = iosync[0];
p_ufd->events = POLLIN | POLLHUP;
p_ufd ++;
port = first;
while(port)
{
p_ufd->fd = port->so;
p_ufd->events =
( port->detect_disconnect ? POLLHUP : 0 )
| ( port->detect_output ? POLLOUT : 0 )
| ( port->detect_pending ? POLLIN : 0 )
;
port->ufd = p_ufd;
p_ufd ++;
port = port->next;
}
}
MUTEX_END
poll( mfd.getList(), lastcount, timer );
#else
MUTEX_START
onEvent();
port = first;
while(port)
{
onCallback(port);
so = port->so;
if(FD_ISSET(so, &err)) {
port->detect_disconnect = false;
SocketPort* p = port;
port = port->next;
p->disconnect();
continue;
}
if(FD_ISSET(so, &inp))
port->pending();
if(FD_ISSET(so, &out))
port->output();
retry:
expires = port->getTimer();
if(expires > 0)
if(expires < timer)
timer = expires;
// if we expire, get new scheduling now
if(!expires)
{
port->endTimer();
port->expired();
goto retry;
}
port = port->next;
}
FD_ZERO(&inp);
FD_ZERO(&out);
FD_ZERO(&err);
FD_SET(iosync[0],&inp);
port = first;
while(port)
{
so = port->so;
if(port->detect_pending)
FD_SET(so, &inp);
if(port->detect_output)
FD_SET(so, &out);
if(port->detect_disconnect)
FD_SET(so, &err);
port = port->next;
}
MUTEX_END
if(timer == TIMEOUT_INF)
tvp = NULL;
else
{
tvp = &timeout;
timeout.tv_sec = timer / 1000;
timeout.tv_usec = (timer % 1000) * 1000;
}
select(hiwater, &inp, &out, &err, tvp);
#endif
}
}
void sendReadyToMaster()
{
if (!Wissun()) return;
setCancel(1,"");
sendTripleEscToMaster( 'R', "0");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void QFilterPipeline::on_CancelWorker()
{
setCancel(true);
}
void SocketService::run(void)
{
timeout_t timer, expires;
SocketPort *port;
unsigned char buf;
#ifndef WIN32
#ifdef USE_POLL
Poller mfd;
pollfd * p_ufd;
int lastcount = 0;
// initialize ufd in all attached ports :
// probably don't need this but it can't hurt.
enterMutex();
port = first;
while(port) {
port->ufd = 0;
port = port->next;
}
leaveMutex();
#else
struct timeval timeout, *tvp;
fd_set inp, out, err;
FD_ZERO(&inp);
FD_ZERO(&out);
FD_ZERO(&err);
int so;
#endif
#else // WIN32
int numHandle = 0;
HANDLE hv[MAXIMUM_WAIT_OBJECTS];
#endif
#ifdef WIN32
// FIXME: needed ?
ResetEvent(sync->GetSync());
#endif
setCancel(cancelDeferred);
for(;;) {
timer = TIMEOUT_INF;
#ifndef WIN32
while(1 == ::read(iosync[0], (char *)&buf, 1)) {
#else
for(;;) {
int f = sync->getFlag();
if (f < 0)
break;
buf = f;
#endif
if(buf) {
onUpdate(buf);
continue;
}
setCancel(cancelImmediate);
sleep(TIMEOUT_INF);
exit();
}
#ifndef WIN32
#ifdef USE_POLL
bool reallocate = false;
MUTEX_START
onEvent();
port = first;
while(port) {
onCallback(port);
if ( ( p_ufd = port->ufd ) ) {
if ( ( POLLHUP | POLLNVAL ) & p_ufd->revents ) {
// Avoid infinite loop from disconnected sockets
port->detect_disconnect = false;
p_ufd->events &= ~POLLHUP;
SocketPort* p = port;
port = port->next;
detach(p);
reallocate = true;
p->disconnect();
continue;
}
if ( ( POLLIN | POLLPRI ) & p_ufd->revents )
port->pending();
if ( POLLOUT & p_ufd->revents )
port->output();
} else {
reallocate = true;
}
retry:
expires = port->getTimer();
if(expires > 0)
if(expires < timer)
timer = expires;
if(!expires) {
port->endTimer();
port->expired();
goto retry;
}
port = port->next;
}
//
// reallocate things if we saw a ServerPort without
// ufd set !
if ( reallocate || ( ( count + 1 ) != lastcount ) ) {
lastcount = count + 1;
p_ufd = mfd.getList( count + 1 );
// Set up iosync polling
p_ufd->fd = iosync[0];
p_ufd->events = POLLIN | POLLHUP;
p_ufd ++;
port = first;
while(port) {
p_ufd->fd = port->so;
p_ufd->events =
( port->detect_disconnect ? POLLHUP : 0 )
| ( port->detect_output ? POLLOUT : 0 )
| ( port->detect_pending ? POLLIN : 0 )
;
port->ufd = p_ufd;
p_ufd ++;
port = port->next;
}
}
MUTEX_END
poll( mfd.getList(), lastcount, timer );
#else
MUTEX_START
onEvent();
port = first;
while(port) {
onCallback(port);
so = port->so;
if(FD_ISSET(so, &err)) {
port->detect_disconnect = false;
SocketPort* p = port;
port = port->next;
p->disconnect();
continue;
}
if(FD_ISSET(so, &inp))
port->pending();
if(FD_ISSET(so, &out))
port->output();
retry:
expires = port->getTimer();
if(expires > 0)
if(expires < timer)
timer = expires;
// if we expire, get new scheduling now
if(!expires) {
port->endTimer();
port->expired();
goto retry;
}
port = port->next;
}
FD_ZERO(&inp);
FD_ZERO(&out);
FD_ZERO(&err);
FD_SET(iosync[0],&inp);
port = first;
while(port) {
so = port->so;
if(port->detect_pending)
FD_SET(so, &inp);
if(port->detect_output)
FD_SET(so, &out);
if(port->detect_disconnect)
FD_SET(so, &err);
port = port->next;
}
MUTEX_END
if(timer == TIMEOUT_INF)
tvp = NULL;
else {
tvp = &timeout;
timeout.tv_sec = timer / 1000;
timeout.tv_usec = (timer % 1000) * 1000;
}
select(hiwater, &inp, &out, &err, tvp);
#endif
#else // WIN32
MUTEX_START
onEvent();
hv[0] = sync->GetSync();
numHandle = 1;
port = first;
while(port) {
onCallback(port);
long events = 0;
if(port->detect_pending)
events |= FD_READ;
if(port->detect_output)
events |= FD_WRITE;
if(port->detect_disconnect)
events |= FD_CLOSE;
// !!! ignore some socket on overflow !!!
if (events && numHandle < MAXIMUM_WAIT_OBJECTS) {
WSAEventSelect(port->so,port->event,events);
hv[numHandle++] = port->event;
}
retry:
expires = port->getTimer();
if(expires > 0)
if(expires < timer)
timer = expires;
// if we expire, get new scheduling now
if(!expires) {
port->endTimer();
port->expired();
goto retry;
}
port = port->next;
}
MUTEX_END
// FIXME: handle thread cancellation correctly
DWORD res = WaitForMultipleObjects(numHandle,hv,FALSE,timer);
switch (res) {
case WAIT_OBJECT_0:
break;
case WAIT_TIMEOUT:
break;
default:
// FIXME: handle failures (detach SocketPort)
if (res >= WAIT_OBJECT_0+1 && res <= WAIT_OBJECT_0+MAXIMUM_WAIT_OBJECTS) {
int curr = res - (WAIT_OBJECT_0);
WSANETWORKEVENTS events;
// search port
MUTEX_START
port = first;
while(port) {
if (port->event == hv[curr])
break;
port = port->next;
}
MUTEX_END
// if port not found ignore
if (!port || port->event != hv[curr])
break;
WSAEnumNetworkEvents(port->so,port->event,&events);
if(events.lNetworkEvents & FD_CLOSE) {
port->detect_disconnect = false;
port->disconnect();
continue;
}
if(events.lNetworkEvents & FD_READ)
port->pending();
if(events.lNetworkEvents & FD_WRITE)
port->output();
}
}
#endif
}
}
