void mapper_monitor_link(mapper_monitor mon,
const char* source_device,
const char* dest_device,
mapper_db_link_t *props,
unsigned int props_flags)
{
if (props && (props_flags & LINK_NUM_SCOPES) && props->num_scopes &&
((props_flags & LINK_SCOPE_NAMES) || (props_flags & LINK_SCOPE_HASHES))) {
lo_message m = lo_message_new();
if (!m)
return;
lo_message_add_string(m, source_device);
lo_message_add_string(m, dest_device);
lo_message_add_string(m, "@scope");
int i;
if (props_flags & LINK_SCOPE_NAMES) {
for (i=0; i<props->num_scopes; i++) {
lo_message_add_string(m, props->scope_names[i]);
}
}
else if (props_flags & LINK_SCOPE_HASHES) {
for (i=0; i<props->num_scopes; i++) {
lo_message_add_int32(m, props->scope_hashes[i]);
}
}
lo_send_message(mon->admin->admin_addr, "/link", m);
free(m);
}
else
mapper_admin_send_osc( mon->admin, 0, "/link", "ss",
source_device, dest_device );
}
void mapper_slot_add_props_to_message(lo_message msg, mapper_slot slot,
int is_dest, int staged)
{
char temp[16];
if (is_dest)
snprintf(temp, 16, "@dst");
else if (slot->id == 0)
snprintf(temp, 16, "@src");
else
snprintf(temp, 16, "@src.%d", slot->id);
int len = strlen(temp);
if (!staged && slot->signal->local) {
// include length from associated signal
snprintf(temp+len, 16-len, "%s", mapper_protocol_string(AT_LENGTH));
lo_message_add_string(msg, temp);
lo_message_add_int32(msg, slot->signal->length);
// include type from associated signal
snprintf(temp+len, 16-len, "%s", mapper_protocol_string(AT_TYPE));
lo_message_add_string(msg, temp);
lo_message_add_char(msg, slot->signal->type);
}
mapper_table_add_to_message(0, staged ? slot->staged_props : slot->props,
msg);
if (staged) {
// clear the staged properties
mapper_table_clear(slot->staged_props);
}
}
void veejay_bundle_sample_add( void *osc, int id, const char *word, const char *format, ... )
{
char osc_path[256];
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
sprintf(osc_path, "/sample_%d/%s", id, word );
lo_message lmsg = lo_message_new();
lo_message_add_string(lmsg, c->window );
lo_message_add_string(lmsg, osc_path );
va_list ap;
if( format )
{
va_start( ap, format );
veejay_add_arguments_( lmsg, format, ap );
va_end(ap);
}
lo_bundle_add_message( c->bundle, "/update/widget", lmsg );
}
//================================================================
void io_dump_config()
{
if(io_())
{
lo_message msgio=lo_message_new();
//common properties with jack_audio_send first
lo_message_add_int32(msgio,atoi(localPort)); //0
//local jack info
lo_message_add_string(msgio,client_name); //1
lo_message_add_string(msgio,server_name); //2
lo_message_add_int32(msgio,sample_rate); //3
lo_message_add_int32(msgio,period_size); //4
lo_message_add_int32(msgio,output_port_count); //5
//this is not a property of local JACK
lo_message_add_int32(msgio,bytes_per_sample); //6
lo_message_add_int32(msgio,test_mode); //7
lo_message_add_int32(msgio,receive_max); //8
//gap for future common props
lo_message_add_int32(msgio,0); //9
lo_message_add_int32(msgio,0); //10
lo_message_add_int32(msgio,0); //11
lo_message_add_int32(msgio,0); //12
lo_message_add_int32(msgio,0); //13
lo_message_add_int32(msgio,0); //14
lo_message_add_int32(msgio,0); //15
lo_message_add_int32(msgio,0); //16
lo_message_add_int32(msgio,0); //17
lo_message_add_int32(msgio,0); //18
lo_message_add_int32(msgio,0); //19
//custom properties start here
lo_message_add_int32(msgio,channel_offset); //20
//multi-channel period size
// lo_message_add_float(msgio,output_port_count*period_size*bytes_per_sample);
lo_message_add_int32(msgio,zero_on_underflow); //21
lo_message_add_int32(msgio,rebuffer_on_restart); //22
lo_message_add_int32(msgio,rebuffer_on_underflow); //23
lo_message_add_int32(msgio,allow_remote_buffer_control); //24
lo_message_add_int32(msgio,close_on_incomp); //25
// fprintf(stderr,"receiving on TCP port: %s\n",localPort);
// fprintf(stderr,"receiving on UDP port: %s\n",localPort);
// lo_message_add_int32(msgio,max_buffer_size);
//should be global
// lo_message_add_int32(msgio,rb_size);
lo_send_message(loio, "/config_dump", msgio);
lo_message_free(msgio);
}//end if io_
}//end io_dump_config
//=========================================================
void io_simple_string_double(char *path, const char *string1, const char *string2)
{
if(io_())
{
lo_message msgio=lo_message_new();
lo_message_add_string(msgio, string1);
lo_message_add_string(msgio, string2);
lo_send_message(loio, path, msgio);
lo_message_free(msgio);
}
}
void nfosc_stop() {
int i;
if (!running) return;
running = false;
if( main_thread ) pthread_detach(main_thread);
main_thread = NULL;
lo_bundle osc_bundle = lo_bundle_new(LO_TT_IMMEDIATE);
for (i=0;i<buffer_size;i++) {
lo_message del_message = lo_message_new();
lo_message_add_int32(del_message, tag_buffer[i].device_id);
lo_message_add_int32(del_message, tag_buffer[i].symbol_id);
lo_message_add_int32(del_message, tag_buffer[i].type_id);
lo_message_add_string(del_message, tag_buffer[i].uid_str);
lo_bundle_add_message(osc_bundle, "/nfosc/del", del_message);
if (verbose) printf("del %d %d %d %s\n",tag_buffer[i].session_id,tag_buffer[i].symbol_id,tag_buffer[i].type_id,tag_buffer[i].uid_str);
}
lo_timetag frame_time;
lo_timetag_now (&frame_time);
for (int dev=0;dev<no_devices;dev++) {
if (pnd[dev]==NULL) continue;
lo_message frm_message = lo_message_new();
lo_message_add_int32(frm_message, -1);
lo_message_add_timetag(frm_message, frame_time);
lo_message_add_int32(frm_message, 0); // sensor dim
if (device_count>1) sprintf(source_string, "NFOSC:%d",dev);
lo_message_add_string(frm_message, source_string); // source name
lo_bundle_add_message(osc_bundle, "/tuio2/frm", frm_message);
lo_message sid_message = lo_message_new();
lo_bundle_add_message(osc_bundle, "/tuio2/alv", sid_message);
}
int ret = lo_send_bundle(target, osc_bundle);
if(ret == -1) {
fprintf(stderr, "an OSC error occured: %s\n", lo_address_errstr(target));
exit(1);
}
for (int dev=0;dev<no_devices;dev++) {
if (pnd[dev]!=NULL) {
printf("closing NFC reader #%d: %s\n",dev,nfc_device_get_name(pnd[dev]));
nfc_close(pnd[dev]);
}
}
nfc_exit(context);
write_database();
}
void *veejay_message_new_widget( void *osc, const char *str1,const char *str2, int n_names )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
lo_message lmsg = lo_message_new();
lo_message_add_string( lmsg, str1 );
lo_message_add_string( lmsg, str2 );
lo_message_add_int32( lmsg, n_names );
return (void*) lmsg;
}
void
Mixer::discover_peers ( void )
{
if ( nsm->is_active() )
{
lo_message m = lo_message_new();
lo_message_add_string( m, "/non/finger" );
lo_message_add_string( m, osc_endpoint->url() );
nsm->broadcast( m );
lo_message_free( m );
}
}
void veejay_bundle_sample_add_fx_atom( void *osc, int id,int entry, const char *word, const char *format, int type, void *value )
{
char osc_path[256];
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
sprintf(osc_path, "/sample_%d/fx_%d/%s", id, entry,word );
lo_message lmsg = lo_message_new();
char realwin[128];
sprintf(realwin, "%sFX%d", c->window, entry );
lo_message_add_string(lmsg, realwin );
lo_message_add_string(lmsg, osc_path );
int ival;
char *str;
double gval;
uint64_t val;
switch(type)
{
case VEVO_ATOM_TYPE_STRING:
str = (char*) *( (char*) value);
lo_message_add_string( lmsg, str );
break;
case VEVO_ATOM_TYPE_BOOL:
case VEVO_ATOM_TYPE_INT:
ival = (int) *( (int*) value );
lo_message_add_int32( lmsg, ival );
break;
case VEVO_ATOM_TYPE_DOUBLE:
gval = (double) *( (double*) value );
lo_message_add_double( lmsg, gval );
break;
case VEVO_ATOM_TYPE_UINT64:
val = (uint64_t) *( (uint64_t*) value );
lo_message_add_int64( lmsg, (int64_t) val );
break;
default:
lo_message_free( lmsg );
return;
break;
}
lo_bundle_add_message( c->bundle,"/update/widget", lmsg );
}
lo_message make_message(int i, char *s)
{
lo_message msg = lo_message_new();
lo_message_add_int32(msg, i);
lo_message_add_string(msg, s);
return msg;
}
void Client::send( const osc::Message &message )
{
lo_message msg = lo_message_new();
for ( size_t i = 0; i < message.getNumArgs(); i++ )
{
switch ( message.getArgType( i ) )
{
case 'i':
lo_message_add_int32( msg, message.getArg< int32_t >( i ) );
break;
case 'f':
lo_message_add_float( msg, message.getArg< float >( i ) );
break;
case 's':
lo_message_add_string( msg, message.getArg< std::string >( i ).c_str() );
break;
default:
break;
}
}
lo_send_message( mAddress, message.getAddressPattern().c_str(), msg );
lo_message_free( msg );
}
int osc_controller::_add_cb(const char* path, const char* types,
lo_arg** argv, int argc, lo_message msg)
{
if (!m_restricted || is_target(lo_message_get_source(msg))) {
pair<int,int> net_id(argv[0]->i, argv[1]->i);
m_skip++;
world_node obj = m_world->add_node(std::string(&argv[2]->s));
m_skip--;
if (!obj.is_null()) {
int local_id = obj.get_id ();
m_net_id[local_id] = net_id;
m_local_id[net_id] = local_id;
if (m_broadcast) {
lo_message newmsg = lo_message_new();
lo_message_add_int32(newmsg, argv[0]->i);
lo_message_add_int32(newmsg, argv[1]->i);
lo_message_add_string(newmsg, &argv[2]->s);
broadcast_message_from(PSYNTH_OSC_MSG_ADD, newmsg, lo_message_get_source(msg));
lo_message_free(newmsg);
}
}
}
return 0;
}
static void veejay_add_arguments_ ( lo_message lmsg, const char *format, va_list ap )
{
//http://liblo.sourceforge.net/docs/group__liblolowlevel.html#g31ac1e4c0ec6c61f665ce3f9bbdc53c3
while( *format != 'x' && *format != '\0' )
{
switch(*format)
{
case 'i':
lo_message_add_int32( lmsg, (int32_t) va_arg( ap, int));
break;
case 'h':
lo_message_add_int64( lmsg, (int64_t) va_arg( ap, int64_t));
break;
case 's':
{ char *str = (char*) va_arg(ap,char*);
lo_message_add_string( lmsg, str ); }
break;
case 'd':
// double g = (double) *(va_arg(ap, double*));
{ double g = (double) va_arg(ap,double);
lo_message_add_double( lmsg, g); }
break;
default:
break;
}
*format ++;
}
}
// Generate OSC message with default format
void genOscMsg(lo_bundle *bundle, char *name, int buffIndex) {
if (handMode || posConfidence >= 0.5f)
{
lo_message msg = lo_message_new();
lo_message_add_string(msg, name);
if (!kitchenMode)
lo_message_add_int32(msg, userID);
for (int i = 0; i < nDimensions; i++)
lo_message_add_float(msg, jointCoords[i]);
lo_bundle_add_message(*bundle, "/joint", msg);
}
if (!kitchenMode && sendOrient && orientConfidence >= 0.5f)
{
lo_message msg = lo_message_new();
lo_message_add_string(msg, name);
if (!kitchenMode)
lo_message_add_int32(msg, userID);
// x data is in first column
lo_message_add_float(msg, jointOrients[0]);
lo_message_add_float(msg, jointOrients[0+3]);
lo_message_add_float(msg, jointOrients[0+6]);
// y data is in 2nd column
lo_message_add_float(msg, jointOrients[1]);
lo_message_add_float(msg, jointOrients[1+3]);
lo_message_add_float(msg, jointOrients[1+6]);
// z data is in 3rd column
lo_message_add_float(msg, jointOrients[2]);
lo_message_add_float(msg, jointOrients[2+3]);
lo_message_add_float(msg, jointOrients[2+6]);
lo_bundle_add_message(*bundle, "/orient", msg);
}
}
void veejay_bundle_add_atom( void *osc, const char *osc_path, const char *format, int type, void *value )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
lo_message lmsg = lo_message_new();
lo_message_add_string( lmsg,c->window );
lo_message_add_string( lmsg,osc_path );
int ival;
char *str;
double gval;
uint64_t val;
switch(type)
{
case VEVO_ATOM_TYPE_STRING:
str = (char*) *( (char*) value);
lo_message_add_string( lmsg, str );
break;
case VEVO_ATOM_TYPE_BOOL:
case VEVO_ATOM_TYPE_INT:
ival = (int) *( (int*) value );
lo_message_add_int32( lmsg, ival );
break;
case VEVO_ATOM_TYPE_DOUBLE:
gval = (double) *( (double*) value );
lo_message_add_double( lmsg, gval );
break;
case VEVO_ATOM_TYPE_UINT64:
val = (uint64_t) *( (uint64_t*) value );
lo_message_add_int64( lmsg, (int64_t) val );
break;
default:
lo_message_free( lmsg );
return;
break;
}
lo_bundle_add_message( c->bundle, "/update/widget", lmsg );
}
//=========================================================
void io_quit(char *token)
{
if(io_())
{
lo_message msgio=lo_message_new();
lo_message_add_string(msgio,token);
lo_send_message(loio, "/quit", msgio);
lo_message_free(msgio);
}
}
void veejay_bundle_plugin_add( void *osc, const char *window, const char *path, const char *format, void *value )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
lo_message lmsg = lo_message_new();
lo_message_add_string(lmsg, window );
lo_message_add_string(lmsg, path );
int n_elem = strlen( format );
int ival;
char *str;
double gval;
uint64_t val;
switch(*format)
{
case 's':
str = (char*) *( (char*) value);
lo_message_add_string( lmsg, str );
break;
case 'i':
ival = (int) *( (int*) value );
lo_message_add_int32( lmsg, ival );
break;
case 'd':
gval = (double) *( (double*) value );
lo_message_add_double( lmsg, gval );
break;
case 'h':
val = (uint64_t) *( (uint64_t*) value );
lo_message_add_int64( lmsg, (int64_t) val );
break;
default:
lo_message_free( lmsg );
return;
break;
}
lo_bundle_add_message( c->bundle,"/update/widget", lmsg );
}
// parse a list of Prolog terms and add arguments to an OSC message
static int add_msg_args(lo_message msg, term_t list)
{
term_t head=PL_new_term_ref();
// copy term ref so as not to modify original
list=PL_copy_term_ref(list);
while (PL_get_list(list,head,list)) {
atom_t name;
int arity;
const char *type;
if (!PL_get_name_arity(head,&name,&arity)) return type_error(head,"term");
type=PL_atom_chars(name);
switch (arity) {
case 1: {
term_t a1=PL_new_term_ref();
PL_get_arg(1,head,a1);
if (!strcmp(type,"int")) {
int x;
if (!PL_get_integer(a1,&x)) return type_error(a1,"integer");
lo_message_add_int32(msg,x);
} else if (!strcmp(type,"double")) {
double x;
if (!PL_get_float(a1,&x)) return type_error(a1,"float");
lo_message_add_double(msg,x);
} else if (!strcmp(type,"string")) {
char *x;
if (!PL_get_chars(a1,&x,CVT_ATOM|CVT_STRING)) return type_error(a1,"string");
lo_message_add_string(msg,x);
} else if (!strcmp(type,"symbol")) {
char *x;
if (!PL_get_chars(a1,&x,CVT_ATOM)) return type_error(a1,"atom");
lo_message_add_symbol(msg,x);
} else if (!strcmp(type,"float")) {
double x;
if (!PL_get_float(a1,&x)) return type_error(a1,"float");
lo_message_add_float(msg,(float)x);
}
break;
}
case 0: {
if (!strcmp(type,"true")) lo_message_add_true(msg);
else if (!strcmp(type,"false")) lo_message_add_false(msg);
else if (!strcmp(type,"nil")) lo_message_add_nil(msg);
else if (!strcmp(type,"inf")) lo_message_add_infinitum(msg);
break;
}
}
}
if (!PL_get_nil(list)) return type_error(list,"nil");
return TRUE;
}
void ModuleManager::deleteModuleList()
{
int sock, n, d_len;
struct sockaddr_in addr;
void *data;
char path[] = "/ModuleList/deleteMList";
char p[64];
int mColor;
strcpy(p, OSCAddr);
strcat(p, mPath);
//create lo_message
lo_message m = lo_message_new();
lo_message_add_string(m, IPAddr);
lo_message_add_string(m, p);
lo_message_add_int32(m, mColor);
data = lo_message_serialise(m, path, NULL, NULL);
d_len = lo_message_length(m, path);
//create socket
int opt = 1;
sock = socket(AF_INET, SOCK_DGRAM, 0);
setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &opt, sizeof(int));
addr.sin_family = AF_INET;
addr.sin_port = htons(6340);
inet_pton(AF_INET, "255.255.255.255", &addr.sin_addr.s_addr);
//send(念のため3回)
for (int j=0; j<3; j++) {
n = sendto(sock, data, d_len, 0, (struct sockaddr *)&addr, sizeof(addr));
if (n < 1) {
perror("sendto");
}
usleep(1000);
}
lo_message_free(m);
close(sock);
}
int text_read(char **_path, lo_message *_m, lo_timetag *_tt)
{
const char *delim = " \r\n";
char str[1024];
if (!fgets(str, 1024, input_file))
return 1;
char *t, *p, *s = strtok_r(str, delim, &p);
lo_timetag tt;
lo_message m = lo_message_new();
char *path;
if (s) {
tt.sec = atoi(s);
}
s = strtok_r(0, delim, &p);
if (s) {
tt.frac = atoi(s);
}
s = strtok_r(0, delim, &p);
if (s) {
path = s;
}
s = strtok_r(0, delim, &p);
if (s) {
t = s;
}
while ((s = strtok_r(0, delim, &p))) {
switch (*t) {
case 'i':
lo_message_add_int32(m, atoi(s));
break;
case 'f':
lo_message_add_float(m, atof(s));
break;
case 's':
lo_message_add_string(m, s);
break;
}
if (*(t+1))
t++;
}
_tt->sec = tt.sec;
_tt->frac = tt.frac;
*_m = m;
*_path = strdup(path);
return 0;
}
int veejay_send_osc_strargs( void *osc, const char *msg, int n_str, char **strs )
{
oscclient_t *c = (oscclient_t*) osc;
lo_message lmsg = lo_message_new();
int i;
for( i = 0; i < n_str; i ++ )
{
lo_message_add_string( lmsg, strs[i] );
}
int result = lo_send_message( c->addr, msg, lmsg );
lo_message_free( lmsg );
return result;
}
void send_joystick_info(int joy_idx)
{
SDL_Joystick * joy = joysticks.find( joy_idx )->second;
lo_message m1 = lo_message_new();
lo_message_add_string( m1, SDL_JoystickName(joy_idx) );
lo_message_add_int32( m1, joy_idx );
lo_message_add_int32( m1, SDL_JoystickNumAxes(joy) );
lo_message_add_int32( m1, SDL_JoystickNumButtons(joy) );
lo_message_add_int32( m1, SDL_JoystickNumHats(joy) );
lo_message_add_int32( m1, SDL_JoystickNumBalls(joy) );
lo_send_message_from( t, s, "/joystick/info", m1 );
}
void veejay_bundle_add( void *osc, const char *msg, const char *format, ... )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
lo_message lmsg = lo_message_new();
lo_message_add_string(lmsg, c->window );
lo_message_add_string(lmsg, msg );
va_list ap;
if( format )
{
va_start( ap, format );
veejay_add_arguments_( lmsg, format, ap );
va_end(ap);
}
lo_bundle_add_message( c->bundle, "/update/widget", lmsg );
}
lo_message get_joystick_info_msg(int joy_idx, SDL_Joystick * joy )
{
// SDL_Joystick * joy = joysticks.find( joy_idx )->second;
lo_message m1 = lo_message_new();
lo_message_add_string( m1, SDL_JoystickName(joy_idx) );
lo_message_add_int32( m1, joy_idx );
lo_message_add_int32( m1, SDL_JoystickNumAxes(joy) );
lo_message_add_int32( m1, SDL_JoystickNumButtons(joy) );
lo_message_add_int32( m1, SDL_JoystickNumHats(joy) );
lo_message_add_int32( m1, SDL_JoystickNumBalls(joy) );
// lo_send_message_from( t, s, "/joystick/info", m1 );
return m1;
}
int mapper_router_send_query(mapper_router rtr, mapper_signal sig,
mapper_timetag_t tt)
{
if (!sig->local->update_handler) {
trace("not sending queries since signal has no handler.\n");
return 0;
}
// find the corresponding router_signal
mapper_router_signal rs = rtr->signals;
while (rs && rs->signal != sig)
rs = rs->next;
// exit without failure if signal is not mapped
if (!rs)
return 0;
// for each map, query remote signals
int i, j, count = 0;
char query_string[256];
for (i = 0; i < rs->num_slots; i++) {
if (!rs->slots[i])
continue;
mapper_map map = rs->slots[i]->map;
if (map->status != STATUS_ACTIVE)
continue;
lo_message msg = lo_message_new();
if (!msg)
continue;
lo_message_add_string(msg, sig->path);
lo_message_add_int32(msg, sig->length);
lo_message_add_char(msg, sig->type);
// TODO: include response address as argument to allow TCP queries?
// TODO: always use TCP for queries?
if (rs->slots[i]->direction == MAPPER_DIR_OUTGOING) {
snprintf(query_string, 256, "%s/get", map->destination.signal->path);
send_or_bundle_message(map->destination.link, query_string, msg, tt);
}
else {
for (j = 0; j < map->num_sources; j++) {
snprintf(query_string, 256, "%s/get", map->sources[j]->signal->path);
send_or_bundle_message(map->sources[j]->link, query_string, msg, tt);
}
}
++count;
}
return count;
}
void osc_controller::handle_set_param_node(world_node& obj, int param_id)
{
if (!m_skip) {
int local_id(obj.get_id ());
pair<int,int> net_id = m_net_id[local_id];
lo_message msg = lo_message_new();
lo_message_add_int32(msg, net_id.first);
lo_message_add_int32(msg, net_id.second);
lo_message_add_int32(msg, param_id);
switch(obj.get_param_type(param_id)) {
case graph::node_param::INT: {
int val;
obj.get_param(param_id, val);
lo_message_add_int32(msg, val);
break;
}
case graph::node_param::FLOAT: {
float val;
obj.get_param(param_id, val);
lo_message_add_float(msg, val);
break;
}
case graph::node_param::STRING: {
string val;
obj.get_param(param_id, val);
lo_message_add_string(msg, val.c_str());
break;
}
case graph::node_param::VECTOR2F: {
base::vector_2f val;
obj.get_param(param_id, val);
lo_message_add_float(msg, val.x);
lo_message_add_float(msg, val.y);
break;
}
default:
break;
}
broadcast_message(PSYNTH_OSC_MSG_PARAM, msg);
lo_message_free(msg);
}
}
static void
client_callback (const char* client, int yn, void* arg)
{
lo_message reply=lo_message_new();
lo_message_add_string(reply,client);
if(yn)
{
lo_send_message (loa, "/oscev/client/registered", reply);
}
else
{
lo_send_message (loa, "/oscev/client/unregistered", reply);
}
lo_message_free (reply);
printf ("Client %s %s\n", client, (yn ? "registered" : "unregistered"));
}
void osc_controller::handle_add_node(world_node& obj)
{
if (!m_skip) {
int local_id(obj.get_id ());
pair<int,int> net_id(m_id, local_id);
m_local_id[net_id] = local_id;
m_net_id[local_id] = net_id;
lo_message msg = lo_message_new();
lo_message_add_int32(msg, net_id.first);
lo_message_add_int32(msg, net_id.second);
lo_message_add_string(msg, obj.get_name().c_str());
broadcast_message(PSYNTH_OSC_MSG_ADD, msg);
lo_message_free(msg);
}
}
void *veejay_message_new_linked_pulldown( void *osc, const char *str1,const char *str2, const char *str3,
const char *str4, const char *format , const char *tooltip)
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
lo_message lmsg = lo_message_new();
lo_message_add_string( lmsg, str1 );
lo_message_add_string( lmsg, str2 );
lo_message_add_string( lmsg, str3 );
lo_message_add_string( lmsg, str4 );
lo_message_add_string( lmsg, format );
lo_message_add_string( lmsg, tooltip );
return (void*) lmsg;
}
void *veejay_message_new_pulldown( void *osc, const char *str1,const char *str2, const char *id, const char *str3,
const char *str4, double dv, const char *tooltip )
{
oscclient_t *c = (oscclient_t*) osc;
if(!c->bundle)
{
c->bundle = lo_bundle_new( LO_TT_IMMEDIATE );
}
lo_message lmsg = lo_message_new();
lo_message_add_string( lmsg, str1 );
lo_message_add_string( lmsg, str2 );
lo_message_add_string( lmsg, id );
lo_message_add_string( lmsg, str3 );
lo_message_add_string( lmsg, str4 );
lo_message_add_double( lmsg, dv );
lo_message_add_string( lmsg, tooltip );
return (void*) lmsg;
}
