bool Client::connectToServer(const std::string &host, const int port) {
std::unique_lock<std::mutex> lock(connectedEventReceivedMutex);
remoteConnection.reset(new ZeroMQClient(incoming_event_buffer,
outgoing_event_buffer,
host,
port,
port + 1));
if (!remoteConnection->connect()) {
//TODO log the error somewhere.
return false;
}
// Send client connected event, using memory address of remoteConnection as the client ID
putEvent(SystemEventFactory::clientConnectedToServerControl(reinterpret_cast<long>(remoteConnection.get())));
// Wait for connection acknowledgement from server
connectedEventReceived = false;
if (!connectedEventReceivedCondition.wait_for(lock,
std::chrono::seconds(2),
[this]() { return connectedEventReceived; }))
{
(void)disconnectClient();
return false;
}
// Request component codec, variable codec, experiment state, and protocol names
putEvent(SystemEventFactory::requestComponentCodecControl());
putEvent(SystemEventFactory::requestCodecControl());
putEvent(SystemEventFactory::requestExperimentStateControl());
putEvent(SystemEventFactory::requestProtocolsControl());
return true;
}
void interrupt10ms(void)
{
Tenms |= 1; // 10 mS has passed
uint8_t enuk = KEY_MENU;
uint8_t in = readKeys();
for (uint8_t i = 1; i != uint8_t(1 << TRM_BASE); i <<= 1) {
uint8_t value = (in & i);
keys[enuk].input(value);
++enuk;
}
#if defined(REV9E)
checkRotaryEncoder();
static rotenc_t rePreviousValue;
rotenc_t reNewValue = (x9de_rotenc / 2);
int8_t scrollRE = reNewValue - rePreviousValue;
if (scrollRE) {
rePreviousValue = reNewValue;
if (scrollRE < 0) {
putEvent(EVT_KEY_FIRST(KEY_MINUS));
}
else {
putEvent(EVT_KEY_FIRST(KEY_PLUS));
}
}
#endif
}
void TMenuView::do_a_select( TEvent& event )
{
putEvent( event );
event.message.command = owner->execView(this);
if( event.message.command != 0 && commandEnabled(event.message.command) )
{
event.what = evCommand;
event.message.infoPtr = 0;
putEvent(event);
}
clearEvent(event);
}
// peer
void Connection::connect(Address addr)
{
m_last_recieved = porting::getTimeMs();
//MutexAutoLock peerlock(m_peers_mutex);
//m_peers.lock_unique_rec();
auto node = m_peers.find(PEER_ID_SERVER);
if(node != m_peers.end()){
//throw ConnectionException("Already connected to a server");
ConnectionEvent ev(CONNEVENT_CONNECT_FAILED);
putEvent(ev);
}
m_enet_host = enet_host_create(NULL, 1, 0, 0, 0);
ENetAddress address;
#if defined(ENET_IPV6)
if (!addr.isIPv6())
inet_pton (AF_INET6, ("::ffff:"+addr.serializeString()).c_str(), &address.host);
else
address.host = addr.getAddress6().sin6_addr;
#else
if (addr.isIPv6()) {
//throw ConnectionException("Cant connect to ipv6 address");
ConnectionEvent ev(CONNEVENT_CONNECT_FAILED);
putEvent(ev);
} else {
address.host = addr.getAddress().sin_addr.s_addr;
}
#endif
address.port = addr.getPort();
ENetPeer *peer = enet_host_connect(m_enet_host, &address, CHANNEL_COUNT, 0);
peer->data = new u16;
*((u16*)peer->data) = PEER_ID_SERVER;
ENetEvent event;
int ret = enet_host_service (m_enet_host, & event, 5000);
if (ret > 0 && event.type == ENET_EVENT_TYPE_CONNECT) {
m_peers.set(PEER_ID_SERVER, peer);
m_peers_address.set(PEER_ID_SERVER, addr);
} else {
errorstream<<"connect enet_host_service ret="<<ret<<std::endl;
if (ret == 0) {
ConnectionEvent ev(CONNEVENT_CONNECT_FAILED);
putEvent(ev);
}
/* Either the 5 seconds are up or a disconnect event was */
/* received. Reset the peer in the event the 5 seconds */
/* had run out without any significant event. */
enet_peer_reset(peer);
}
}
void TWindow::handleEvent(TEvent &event) {
TRect limits;
TPoint min, max;
TGroup::handleEvent(event);
if (event.what== evCommand)
switch (event.message.command) {
case cmResize:
if ((flags & (wfMove | wfGrow)) != 0) {
limits = owner->getExtent();
sizeLimits(min, max);
dragView(event, dragMode | (flags & (wfMove | wfGrow)),
limits, min, max);
clearEvent(event);
}
break;
case cmClose:
if ((flags & wfClose) != 0 &&
(event.message.infoPtr == 0 || event.message.infoPtr == this))
{
clearEvent(event);
if ((state & sfModal) == 0)
close();
else {
event.what = evCommand;
event.message.command = cmCancel;
putEvent(event);
clearEvent(event);
}
}
break;
case cmZoom:
if ((flags & wfZoom) != 0 &&
(event.message.infoPtr == 0 || event.message.infoPtr == this))
{
zoom();
clearEvent(event);
}
break;
}
else if (event.what == evKeyDown)
switch (event.keyDown.keyCode) {
case kbTab:
focusNext(False);
clearEvent(event);
break;
case kbShiftTab:
focusNext(True);
clearEvent(event);
break;
}
else if (event.what == evBroadcast &&
event.message.command == cmSelectWindowNum &&
event.message.infoInt == number &&
(options & ofSelectable) != 0
) {
select();
clearEvent(event);
}
}
iMPEvent MetronomeSynthIF::getData(MidiPort*, MPEventList* el, iMPEvent i, unsigned pos, int/*ports*/, unsigned n, float** buffer)
{
// Added by Tim. p3.3.18
#ifdef METRONOME_DEBUG
printf("MusE: MetronomeSynthIF::getData\n");
#endif
//set type to unsigned , due to compiler warning: comparison signed/unsigned
unsigned int curPos = pos; //prevent compiler warning: comparison signed/unsigned
unsigned int endPos = pos + n; //prevent compiler warning: comparison signed/unsigned
unsigned int off = pos; //prevent compiler warning: comparison signed/unsigned
int frameOffset = MusEGlobal::audio->getFrameOffset();
for (; i != el->end(); ++i) {
unsigned int frame = i->time() - frameOffset; //prevent compiler warning: comparison signed /unsigned
if (frame >= endPos)
break;
if (frame > curPos) {
if (frame < pos)
printf("should not happen: missed event %d\n", pos -frame);
else
process(buffer, curPos-pos, frame - curPos);
curPos = frame;
}
putEvent(*i);
}
if (endPos - curPos)
process(buffer, curPos - off, endPos - curPos);
return el->end();
}
void Seq::processMessages()
{
for (;;) {
if (toSeq.isEmpty())
break;
SeqMsg msg = toSeq.dequeue();
switch(msg.id) {
case SEQ_TEMPO_CHANGE:
if (playTime != 0) {
int tick = cs->utime2utick(playTime / MScore::sampleRate);
cs->tempomap()->setRelTempo(msg.data);
cs->repeatList()->update();
playTime = cs->utick2utime(tick) * MScore::sampleRate;
}
else
cs->tempomap()->setRelTempo(msg.data);
break;
case SEQ_PLAY:
putEvent(msg.event);
break;
case SEQ_SEEK:
setPos(msg.data);
break;
}
}
}
void Client::sendOpenDataFileEvent(const std::string &filename,
const int options) {
if(filename.size() == 0) { return; }
DatumFileOptions overwrite = options ? M_OVERWRITE : M_NO_OVERWRITE;
putEvent(SystemEventFactory::dataFileOpenControl(filename,
overwrite));
}
void repeatLastCursorMove(uint8_t event)
{
if (CURSOR_MOVED_LEFT(event) || CURSOR_MOVED_RIGHT(event)) {
putEvent(event);
}
else {
m_posHorz = 0;
}
}
void repeatLastCursorMove(uint8_t event)
{
if (CURSOR_MOVED_LEFT(event) || CURSOR_MOVED_RIGHT(event)) {
putEvent(event);
}
else {
menuHorizontalPosition = 0;
}
}
bool Server::closeExperiment(){
if(!GlobalCurrentExperiment){
return false;
}
string expName(GlobalCurrentExperiment->getExperimentName());
putEvent(SystemEventFactory::closeExperimentControl(expName));
return true;
}
void TDialog::handleEvent(TEvent& event)
{
TWindow::handleEvent(event);
switch (event.what)
{
case evKeyDown:
switch (event.keyDown.keyCode)
{
case kbEsc:
event.what = evCommand;
event.message.command = cmCancel;
event.message.infoPtr = 0;
putEvent(event);
clearEvent(event);
break;
case kbEnter:
event.what = evBroadcast;
event.message.command = cmDefault;
event.message.infoPtr = 0;
putEvent(event);
clearEvent(event);
break;
}
break;
case evCommand:
switch( event.message.command )
{
case cmOK:
case cmCancel:
case cmYes:
case cmNo:
if( (state & sfModal) != 0 )
{
endModal(event.message.command);
clearEvent(event);
}
break;
}
break;
}
}
void TDirListBox::handleEvent( TEvent& event )
{
if( event.what == evMouseDown && event.mouse.doubleClick )
{
event.what = evCommand;
event.message.command = cmChangeDir;
putEvent( event );
clearEvent( event );
}
else
TListBox::handleEvent( event );
}
bool Client::sendExperiment(const std::string &expPath) {
namespace bf = boost::filesystem;
if(!remoteConnection->isConnected()) { return false; }
ExperimentPackager packer;
Datum packaged_experiment(packer.packageExperiment(bf::path(expPath)));
if(packaged_experiment.isUndefined()) {
merror(M_CLIENT_MESSAGE_DOMAIN,
"Failed to create a valid packaged experiment.");
// send an update that the experiment load failed
shared_ptr<Event> experimentStateEvent = SystemEventFactory::currentExperimentState();
putEvent(experimentStateEvent);
return false;
}
shared_ptr<Event> experiment_event(new Event(RESERVED_SYSTEM_EVENT_CODE, packaged_experiment));
putEvent(experiment_event);
return true;
}
void TButton::press()
{
message( owner, evBroadcast, cmRecordHistory, 0 );
if( (flags & bfBroadcast) != 0 )
message( owner, evBroadcast, command, this );
else
{
TEvent e;
e.what = evCommand;
e.message.command = command;
e.message.infoPtr = this;
putEvent( e );
}
}
void Shell::idle()
{
TProgram::idle();
// select menu bar if deskTop empty
if( deskTop->current == 0
&& !menuBar->getState( sfSelected ) )
{
TEvent event;
event.what = evCommand;
event.message.command = cmMenu; // put a cmMenu event in queue
putEvent( event );
}
}
bool MidiDevice::putEventWithRetry(const MidiPlayEvent& ev, int tries, long delayUs)
{
// TODO: Er, probably not the best way to do this.
// Maybe try to correlate with actual audio buffer size instead of blind time delay.
for( ; tries > 0; --tries)
{
if(!putEvent(ev)) // Returns true if event cannot be delivered.
return false;
int sleepOk = -1;
while(sleepOk == -1)
sleepOk = usleep(delayUs); // FIXME: usleep is supposed to be depricated!
}
return true;
}
void TStatusLine::handleEvent( TEvent& event )
{
TView::handleEvent(event);
switch (event.what)
{
case evMouseDown:
{
TStatusItem *T = 0;
do {
TPoint mouse = makeLocal( event.mouse.where );
if( T != itemMouseIsIn(mouse) )
drawSelect( T = itemMouseIsIn(mouse) );
} while( mouseEvent( event, evMouseMove ) );
if( T != 0 && commandEnabled(T->command) )
{
event.what = evCommand;
event.message.command = T->command;
event.message.infoPtr = 0;
putEvent(event);
}
clearEvent(event);
drawView();
break;
}
case evKeyDown:
{
for( TStatusItem *T = items; T != 0; T = T->next )
{
if( event.keyDown.keyCode == T->keyCode &&
commandEnabled(T->command))
{
event.what = evCommand;
event.message.command = T->command;
event.message.infoPtr = 0;
return;
}
}
break;
}
case evBroadcast:
if( event.message.command == cmCommandSetChanged )
drawView();
break;
}
}
bool Connection::deletePeer(u16 peer_id, bool timeout)
{
//MutexAutoLock peerlock(m_peers_mutex);
if(m_peers.find(peer_id) == m_peers.end())
return false;
// Create event
ConnectionEvent e;
e.peerRemoved(peer_id, timeout);
putEvent(e);
// delete m_peers[peer_id]; -- enet should handle this
m_peers.erase(peer_id);
m_peers_address.erase(peer_id);
return true;
}
// host
void Connection::serve(Address bind_addr)
{
ENetAddress address;
#if defined(ENET_IPV6)
address.host = bind_addr.getAddress6().sin6_addr; // in6addr_any;
#else
address.host = bind_addr.getAddress().sin_addr.s_addr; // ENET_HOST_ANY;
#endif
address.port = bind_addr.getPort(); // fmtodo
m_enet_host = enet_host_create(&address, g_settings->getU16("max_users"), CHANNEL_COUNT, 0, 0);
if (m_enet_host == NULL) {
ConnectionEvent ev(CONNEVENT_BIND_FAILED);
putEvent(ev);
}
}
void Client::handleEvent(shared_ptr<Event> evt) {
int code = evt->getEventCode();
switch (code) {
case RESERVED_CODEC_CODE:
registry->updateFromCodecDatum(evt->getData());
// Request updated values for all variables
putEvent(SystemEventFactory::requestVariablesUpdateControl());
break;
case RESERVED_SYSTEM_EVENT_CODE: {
auto &sysEvent = evt->getData();
if (sysEvent.getElement(M_SYSTEM_PAYLOAD_TYPE).getInteger() == M_SERVER_CONNECTED_CLIENT) {
long clientID = sysEvent.getElement(M_SYSTEM_PAYLOAD).getInteger();
std::lock_guard<std::mutex> lock(connectedEventReceivedMutex);
if (remoteConnection &&
clientID == reinterpret_cast<long>(remoteConnection.get()))
{
// Received connection acknowledgement from server. Notify any thread waiting
// in connectToServer.
connectedEventReceived = true;
connectedEventReceivedCondition.notify_all();
}
}
break;
}
case RESERVED_TERMINATION_CODE:
mwarning(M_CLIENT_MESSAGE_DOMAIN, "Received termination notification from server; disconnecting");
(void)disconnectClient();
break;
default:
break;
}
handleCallbacks(evt);
if(code >= N_RESERVED_CODEC_CODES && code < registry->getNVariables() + N_RESERVED_CODEC_CODES) {
shared_ptr <Variable> var = registry->getVariable(code);
if(var) {
var->setSilentValue(evt->getData());
} else {
mwarning(M_CLIENT_MESSAGE_DOMAIN, "Invalid variable, client not processing event code: %d", code);
}
}
}
void initPosSetup_boardChange( event_t ev)
{
(void)ev;
if(GetSwitchStates() == TARGET_POSITION)
{
// DEBUG... This just takes us back to the main menu for now...
event_t event = {EV_GOTO_GAME, 0};
DPRINT("Initial state reached\n");
putEvent(EVQ_EVENT_MANAGER, &event);
}
else
{
showDiffs();
}
}
bool Server::openExperiment(const std::string &expPath) {
namespace bf = boost::filesystem;
ExperimentPackager packer;
Datum experiment(packer.packageExperiment(bf::path(expPath)));
if(experiment.isUndefined()) {
merror(M_SERVER_MESSAGE_DOMAIN,
"Failed to create a valid packaged experiment.");
return false;
}
shared_ptr<Event> new_experiment(new Event(RESERVED_SYSTEM_EVENT_CODE,
experiment));
putEvent(new_experiment);
return true;
}
void initPosSetupEntry( event_t ev)
{
inGame_SetPosition( NULL );
if(GetSwitchStates() == TARGET_POSITION)
{
event_t event = {EV_GOTO_GAME, 0};
putEvent(EVQ_EVENT_MANAGER, &event);
}
else
{
displayClear();
displayWriteLine( 0, "Set pieces to", TRUE );
displayWriteLine( 1, "initial position", TRUE );
displayWriteLine( 3, "any btn = go back", TRUE );
showDiffs();
}
}
iMPEvent VstSynthIF::getData(MidiPort* mp, MPEventList* el, iMPEvent i, unsigned pos, int ports, unsigned n, float** buffer)
{
AEffect* plugin = _fst->plugin;
for (; i != el->end(); ++i) {
if (mp)
mp->sendEvent(*i);
else {
if (putEvent(*i))
break;
}
}
if (plugin->flags & effFlagsCanReplacing) {
plugin->processReplacing(plugin, 0, buffer, n);
}
else {
plugin->process(plugin, 0, buffer, n);
}
return el->end();
}
Boolean TChDirDialog::valid( ushort command )
{
if( command != cmOK )
return True;
char path[PATH_MAX];
strcpy( path, dirInput->data );
#ifndef __UNPATCHED
// BUG FIX - EFW - Tue 05/16/95
// Ignore "Drives" line if switching drives.
if(!strcmp(path, drivesText))
path[0] = EOS;
// If it was "Drives" or the input line was blank, issue a
// cmChangeDir event to select the current drive/directory.
if(!path[0])
{
TEvent event;
event.what = evCommand;
event.message.command = cmChangeDir;
putEvent(event);
return False;
}
// Otherwise, expand and check the path.
#endif
fexpand( path );
int len = strlen( path );
/* SS: changed */
if( len > 0 && path[len-1] == '/' )
path[len-1] = EOS;
if( changeDir( path ) != 0 )
{
messageBox( invalidText, mfError | mfOKButton );
return False;
}
return True;
}
void MidiDevice::handleSeek()
{
//---------------------------------------------------
// If playing, clear all notes and flush out any
// stuck notes which were put directly to the device
//---------------------------------------------------
if(MusEGlobal::audio->isPlaying())
{
// TODO: Don't clear, let it play whatever was scheduled ?
//setStopFlag(true);
for(iMPEvent i = _stuckNotes.begin(); i != _stuckNotes.end(); ++i)
{
MidiPlayEvent ev(*i);
ev.setTime(0); // Immediate processing. TODO Use curFrame?
//ev.setTime(MusEGlobal::audio->midiQueueTimeStamp(ev.time()));
putEvent(ev, MidiDevice::NotLate);
}
_stuckNotes.clear();
}
}
void TMenuView::handleEvent( TEvent& event )
{
if( menu != 0 )
switch (event.what)
{
case evMouseDown:
do_a_select(event);
break;
case evKeyDown:
if( findItem(getAltChar(event.keyDown.keyCode)) != 0 )
do_a_select(event);
else
{
TMenuItem *p = hotKey(event.keyDown.keyCode);
if( p != 0 && commandEnabled(p->command))
{
event.what = evCommand;
event.message.command = p->command;
event.message.infoPtr = 0;
putEvent(event);
clearEvent(event);
}
}
break;
case evCommand:
if( event.message.command == cmMenu )
do_a_select(event);
break;
case evBroadcast:
if( event.message.command == cmCommandSetChanged )
{
if( updateMenu(menu) )
drawView();
}
break;
}
}
void Key::input(bool val, EnumKeys enuk)
{
uint8_t t_vals = m_vals ;
t_vals <<= 1 ;
if (val) t_vals |= 1; //portbit einschieben
m_vals = t_vals ;
m_cnt++;
if (m_state && m_vals==0) { //gerade eben sprung auf 0
if (m_state != KSTATE_KILLED) {
putEvent(EVT_KEY_BREAK(enuk));
}
m_cnt = 0;
m_state = KSTATE_OFF;
}
switch(m_state){
case KSTATE_OFF:
if (m_vals == FFVAL) { //gerade eben sprung auf ff
m_state = KSTATE_START;
m_cnt = 0;
}
break;
//fallthrough
case KSTATE_START:
putEvent(EVT_KEY_FIRST(enuk));
inactivity.counter = 0;
m_state = KSTATE_RPTDELAY;
m_cnt = 0;
break;
case KSTATE_RPTDELAY: // gruvin: delay state before first key repeat
if(m_cnt == KEY_LONG_DELAY) putEvent(EVT_KEY_LONG(enuk));
if (m_cnt == 40) {
m_state = 16;
m_cnt = 0;
}
break;
case 16:
case 8:
case 4:
case 2:
if(m_cnt >= 48) { //3 6 12 24 48 pulses in every 480ms
m_state >>= 1;
m_cnt = 0;
}
// no break
case 1:
if( (m_cnt & (m_state-1)) == 0) putEvent(EVT_KEY_REPT(enuk));
break;
case KSTATE_PAUSE: //pause
if(m_cnt >= 64) {
m_state = 8;
m_cnt = 0;
}
break;
case KSTATE_KILLED: //killed
break;
}
// send note off events
foreach(SeqEvent n, activeNotes) {
if (n.type() != ME_NOTEON)
continue;
n.setVelo(0);
putEvent(n);
}
