void bondo_setup(void)
{
bondo_class = class_new(gensym("bondo"),
(t_newmethod)bondo_new,
(t_method)bondo_free,
sizeof(t_bondo), 0, A_GIMME, 0);
class_addbang(bondo_class, bondo_bang);
class_addfloat(bondo_class, bondo_float);
class_addsymbol(bondo_class, bondo_symbol);
class_addpointer(bondo_class, bondo_pointer);
class_addlist(bondo_class, bondo_list);
class_addanything(bondo_class, bondo_anything);
class_addmethod(bondo_class, (t_method)bondo_set,
gensym("set"), A_GIMME, 0);
bondo_proxy_class = class_new(gensym("_bondo_proxy"), 0, 0,
sizeof(t_bondo_proxy),
CLASS_PD | CLASS_NOINLET, 0);
class_addbang(bondo_proxy_class, bondo_proxy_bang);
class_addfloat(bondo_proxy_class, bondo_proxy_float);
class_addsymbol(bondo_proxy_class, bondo_proxy_symbol);
class_addpointer(bondo_proxy_class, bondo_proxy_pointer);
class_addlist(bondo_proxy_class, bondo_proxy_list);
class_addanything(bondo_proxy_class, bondo_proxy_anything);
class_addmethod(bondo_proxy_class, (t_method)bondo_proxy_set,
gensym("set"), A_GIMME, 0);
}
void Append_setup(void)
{
append_class = class_new(gensym("Append"),
(t_newmethod)append_new,
(t_method)append_free,
sizeof(t_append), 0,
A_GIMME, 0);
class_addbang(append_class, append_bang);
class_addfloat(append_class, append_float);
class_addsymbol(append_class, append_symbol);
class_addlist(append_class, append_anything); /* LATER rethink */
class_addanything(append_class, append_anything);
class_addmethod(append_class, (t_method)append_set,
gensym("set"), A_GIMME, 0);
appendxy_class = class_new(gensym("append"), 0, 0, sizeof(t_appendxy),
CLASS_PD | CLASS_NOINLET, 0);
class_addbang(appendxy_class, appendxy_bang);
class_addfloat(appendxy_class, appendxy_float);
class_addsymbol(appendxy_class, appendxy_symbol);
class_addlist(appendxy_class, appendxy_list);
class_addanything(appendxy_class, appendxy_anything);
fitter_setup(append_class, append_fitter);
}
void obj_init(void)
{
inlet_class = class_new(gensym("inlet"), 0, 0,
sizeof(t_inlet), CLASS_PD, 0);
class_addbang(inlet_class, inlet_bang);
class_addpointer(inlet_class, inlet_pointer);
class_addfloat(inlet_class, inlet_float);
class_addsymbol(inlet_class, inlet_symbol);
class_addlist(inlet_class, inlet_list);
class_addanything(inlet_class, inlet_anything);
pointerinlet_class = class_new(gensym("inlet"), 0, 0,
sizeof(t_inlet), CLASS_PD, 0);
class_addpointer(pointerinlet_class, pointerinlet_pointer);
class_addanything(pointerinlet_class, inlet_wrong);
floatinlet_class = class_new(gensym("inlet"), 0, 0,
sizeof(t_inlet), CLASS_PD, 0);
class_addfloat(floatinlet_class, (t_method)floatinlet_float);
class_addanything(floatinlet_class, inlet_wrong);
symbolinlet_class = class_new(gensym("inlet"), 0, 0,
sizeof(t_inlet), CLASS_PD, 0);
class_addsymbol(symbolinlet_class, symbolinlet_symbol);
class_addanything(symbolinlet_class, inlet_wrong);
}
void select_setup(void)
{
sel1_class = class_new(gensym("select"), 0, 0,
sizeof(t_sel1), 0, 0);
class_addfloat(sel1_class, sel1_float);
class_addsymbol(sel1_class, sel1_symbol);
sel2_class = class_new(gensym("select"), 0, (t_method)sel2_free,
sizeof(t_sel2), 0, 0);
class_addfloat(sel2_class, sel2_float);
class_addsymbol(sel2_class, sel2_symbol);
class_addcreator((t_newmethod)select_new, gensym("select"), A_GIMME, 0);
class_addcreator((t_newmethod)select_new, gensym("sel"), A_GIMME, 0);
}
void open_help_setup(void) {
open_help_class = class_new(gensym("open_help"),
(t_newmethod)open_help_new,
(t_method)open_help_free, sizeof(t_open_help),
0,
A_GIMME, 0);
class_addbang(open_help_class, open_help_bang);
//class_addanything(open_help_class,open_help_anything);
class_addsymbol(open_help_class,open_help_symbol);
//class_addmethod(open_help_class,
// (t_method)open_help_append, gensym("append"),
// A_GIMME, 0);
//class_addfloat (open_help_class, open_help_float);
/*class_addmethod(open_help_class,
(t_method)open_help_set, gensym("set"),
A_DEFFLOAT, 0);
*/
//class_addlist (open_help_class, open_help_list);
class_addmethod(open_help_class, (t_method)open_help_click,
gensym("click"),
A_FLOAT, A_FLOAT, A_FLOAT, A_FLOAT, A_FLOAT, 0);
}
void strippath_setup(void)
{
strippath_class = class_new(gensym("strippath"), (t_newmethod)strippath_new, 0,
sizeof(t_strippath), 0, A_DEFFLOAT, 0);
class_addbang(strippath_class, strippath_bang);
class_addsymbol(strippath_class, strippath_symbol);
}
void index_setup(void)
{
index_class = class_new(gensym("index"),
(t_newmethod)index_new, (t_method)index_free,
sizeof(t_index), 0, A_GIMME, 0);
class_addsymbol(index_class, index_symbol);
class_addmethod(index_class, (t_method)index_reset, gensym("reset"), 0);
class_addmethod(index_class, (t_method)index_delete, gensym("delete"), A_GIMME, 0);
/* class_addmethod(index_class, (t_method)index_add, gensym("add"), A_SYMBOL, 0); */
class_addmethod(index_class, (t_method)index_add, gensym("add"), A_SYMBOL, A_DEFFLOAT, 0);
class_addmethod(index_class, (t_method)index_auto, gensym("auto"), A_FLOAT, 0);
class_addmethod(index_class, (t_method)index_resize, gensym("resize"), A_FLOAT, 0);
class_addfloat(index_class, (t_method)index_float);
class_addbang(index_class, (t_method)index_bang);
class_addmethod(index_class, (t_method)index_sort, gensym("sort"), 0);
class_addmethod(index_class, (t_method)index_compact, gensym("compact"), 0);
class_addmethod(index_class, (t_method)index_dump, gensym("dump"), 0);
class_addmethod(index_class, (t_method)index_helper, gensym("help"), 0);
zexy_register("index");
}
void canvasname_setup(void)
{
canvasname_class = class_new(gensym("canvasname"), (t_newmethod)canvasname_new,
(t_method)canvasname_free, sizeof(t_canvasname), 0, A_DEFFLOAT, 0);
class_addsymbol(canvasname_class, (t_method)canvasname_symbol);
class_addbang (canvasname_class, (t_method)canvasname_bang);
}
void oname2l_setup(void)
{
oname2l_class = class_new(gensym("oname2l"), (t_newmethod)oname2l_new,(t_method)oname2l_free, sizeof( t_pd_obj_oname2l), 0,A_DEFSYMBOL, 0);
class_addsymbol(oname2l_class, (t_method)oname2l_symbol);
class_addmethod(oname2l_class, (t_method)oname2l_help, gensym("help"), 0);
class_sethelpsymbol(oname2l_class, gensym("xgui/help_oname2l"));
}
void dist_setup(void)
{
dist_class = class_new(gensym("dist"), (t_newmethod)dist_new, 0,
sizeof(t_dist), 0, A_GIMME, 0);
#else
void maxlib_dist_setup(void)
{
dist_class = class_new(gensym("maxlib_dist"), (t_newmethod)dist_new, 0,
sizeof(t_dist), 0, A_GIMME, 0);
#endif
class_addcreator((t_newmethod)dist_new, gensym("d"), A_GIMME, 0);
class_addbang(dist_class, dist_bang);
class_addfloat(dist_class, dist_float);
class_addsymbol(dist_class, dist_symbol);
class_addpointer(dist_class, dist_pointer);
class_addlist(dist_class, dist_list);
class_addmethod(dist_class, (t_method)dist_connect, gensym("connect"), A_GIMME, 0);
class_addmethod(dist_class, (t_method)dist_disconnect, gensym("disconnect"), A_GIMME, 0);
class_addmethod(dist_class, (t_method)dist_clear, gensym("clear"), 0);
class_addmethod(dist_class, (t_method)dist_print, gensym("print"), 0);
class_addmethod(dist_class, (t_method)dist_send, gensym("send"), A_GIMME, 0);
class_addanything(dist_class, dist_anything);
#ifndef MAXLIB
post(version);
#else
class_addcreator((t_newmethod)dist_new, gensym("dist"), A_GIMME, 0);
class_sethelpsymbol(dist_class, gensym("maxlib/dist-help.pd"));
#endif
}
static void list_fromsymbol_setup(void)
{
list_fromsymbol_class = class_new(gensym("list fromsymbol"),
(t_newmethod)list_fromsymbol_new, 0, sizeof(t_list_fromsymbol), 0, 0);
class_addsymbol(list_fromsymbol_class, list_fromsymbol_symbol);
class_sethelpsymbol(list_fromsymbol_class, &s_list);
}
void hammerfile_setup(t_class *c, int embeddable)
{
if (embeddable)
{
forky_setsavefn(c, hammerembed_save);
class_addmethod(c, (t_method)hammerembed_restore,
gensym("restore"), 0);
}
if (!hammerfile_class)
{
ps__C = gensym("#C");
hammerfile_class = class_new(gensym("_hammerfile"), 0, 0,
sizeof(t_hammerfile),
CLASS_PD | CLASS_NOINLET, 0);
class_addsymbol(hammerfile_class, hammerpanel_symbol);
class_addmethod(hammerfile_class, (t_method)hammerpanel_path,
gensym("path"), A_SYMBOL, A_DEFSYM, 0);
class_addmethod(hammerfile_class, (t_method)hammereditor_clear,
gensym("clear"), 0);
class_addmethod(hammerfile_class, (t_method)hammereditor_addline,
gensym("addline"), A_GIMME, 0);
class_addmethod(hammerfile_class, (t_method)hammereditor_end,
gensym("end"), 0);
/* LATER find a way of ensuring that these are not defined yet... */
hammereditor_guidefs();
hammerpanel_guidefs();
}
}
void grab_setup(void)
{
t_symbol *s = gensym("grab");
grab_class = class_new(s, (t_newmethod)grab_new,
(t_method)grab_free,
sizeof(t_grab), 0,
A_DEFFLOAT, A_DEFSYMBOL, 0);
class_addfloat(grab_class, grab_float);
class_addbang(grab_class, grab_bang);
class_addsymbol(grab_class, grab_symbol);
class_addpointer(grab_class, grab_pointer);
class_addlist(grab_class, grab_list);
class_addanything(grab_class, grab_anything);
class_addmethod(grab_class, (t_method)grab_set,
gensym("set"), A_SYMBOL, 0);
if (!bindlist_class)
{
t_class *c = grab_class;
pd_bind(&grab_class, s);
pd_bind(&c, s);
if (!s->s_thing
|| !(bindlist_class = *s->s_thing)
|| bindlist_class->c_name != gensym("bindlist"))
error("grab: failure to initialize remote grabbing feature");
pd_unbind(&c, s);
pd_unbind(&grab_class, s);
}
}
void basedir_setup(void)
{
basedir_class = class_new(gensym("basedir"),(t_newmethod)basedir_new,
0, sizeof(t_basedir), 0, 0);
class_addsymbol(basedir_class, basedir_symbol);
}
static void makefilename_setup(void)
{
makefilename_class = class_new(gensym("makefilename"),
(t_newmethod)makefilename_new, 0,
sizeof(t_makefilename), 0, A_DEFSYM, 0);
class_addfloat(makefilename_class, makefilename_float);
class_addsymbol(makefilename_class, makefilename_symbol);
}
void plustot_var_setup(void)
{
plustot_var_class = class_new(gensym("+var"), 0,
(t_method)plustot_var_free,
sizeof(t_plustot_var), 0, 0);
plusclass_inherit(plustot_var_class, gensym("+var"));
class_addbang(plustot_var_class, plustot_var_bang);
class_addfloat(plustot_var_class, plustot_var_float);
class_addsymbol(plustot_var_class, plustot_var_symbol);
class_addlist(plustot_var_class, plustot_var_list);
plusproxy_var_class = class_new(gensym("+var proxy"), 0, 0,
sizeof(t_plusproxy_var), CLASS_PD, 0);
class_addfloat(plusproxy_var_class, plusproxy_var_float);
class_addsymbol(plusproxy_var_class, plusproxy_var_symbol);
class_addlist(plusproxy_var_class, plusproxy_var_list);
}
void classtest_setup(void)
{
iemguts_boilerplate("[classtest]", 0);
classtest_class = class_new(gensym("classtest"), (t_newmethod)classtest_new,
(t_method)classtest_free, sizeof(t_classtest), 0,
0);
class_addsymbol(classtest_class, (t_method)classtest_symbol);
}
void stripfilename_setup(void)
{
stripfilename_class = class_new(gensym("stripfilename"), (t_newmethod)stripfilename_new,
0, sizeof(t_stripfilename), 0, A_DEFFLOAT, 0);
class_addsymbol(stripfilename_class, stripfilename_symbol);
class_addmethod(stripfilename_class, (t_method)stripfilename_set, gensym("set"), A_FLOAT, 0);
// class_sethelpsymbol(stripfilename_class, gensym("iemhelp/help-stripfilename"));
}
void spec2_tabreceive_tilde_setup(void)
{
spec2_tabreceive_tilde_class = class_new(gensym("spec2_tabreceive~"), (t_newmethod)spec2_tabreceive_tilde_new,
0, sizeof(t_spec2_tabreceive_tilde), 0, A_DEFSYM, 0);
class_addmethod(spec2_tabreceive_tilde_class, (t_method)spec2_tabreceive_tilde_dsp, gensym("dsp"), 0);
class_addsymbol(spec2_tabreceive_tilde_class, (t_method)spec2_tabreceive_tilde_symbol);
// class_sethelpsymbol(spec2_tabreceive_tilde_class, gensym("iemhelp/spec2_tabreceive~-help"));
}
void pdsymbol_setup(void)
{
pdsymbol_class = class_new(gensym("symbol"), (t_newmethod)pdsymbol_new, 0,
sizeof(t_pdsymbol), 0, A_SYMBOL, 0);
class_addbang(pdsymbol_class, pdsymbol_bang);
class_addsymbol(pdsymbol_class, pdsymbol_symbol);
class_addanything(pdsymbol_class, pdsymbol_anything);
}
void split_path_setup(void)
{
split_path_class = class_new(gensym("split_path"), (t_newmethod)split_path_new, 0,
sizeof(t_split_path), 0,0);
class_addsymbol(split_path_class,split_path_symbol);
logpost(NULL, 4, "[split_path] %s",version);
logpost(NULL, 4, "\twritten by Hans-Christoph Steiner <*****@*****.**>");
}
void cxc_split_setup(void)
{
split_class = class_new(gensym("cxc_split"), (t_newmethod)split_new, 0,
sizeof(t_split), 0,A_DEFSYM,NULL);
// class_addlist(split_class, split_list);
class_addanything(split_class,split_anything);
class_addmethod(split_class, (t_method)split_set, gensym("set"), A_SYMBOL, 0);
class_addsymbol(split_class, split_symbol);
}
void trigger2_setup(void){
trigger2_class = class_new(gensym("trigger2"), (t_newmethod)trigger2_new,
(t_method)trigger2_free, sizeof(t_trigger2), 0, A_GIMME, 0);
class_addlist(trigger2_class, trigger2_list);
class_addbang(trigger2_class, trigger2_bang);
class_addpointer(trigger2_class, trigger2_pointer);
class_addfloat(trigger2_class, (t_method)trigger2_float);
class_addsymbol(trigger2_class, trigger2_symbol);
class_addanything(trigger2_class, trigger2_anything);
}
void strtok_setup(void)
{
strtok_class = class_new(gensym("strtok"), (t_newmethod)strtok_new,
(t_method)strtok_free, sizeof(t_strtok), 0, A_GIMME, 0);
class_addsymbol(strtok_class, (t_method)strtok_anything);
class_addmethod(strtok_class, (t_method)strtok_set, gensym("set"), A_GIMME, 0);
post(". strtok . jasch . "__DATE__" ",0);
}
void flext_base::SetProxies(t_class *c,bool dsp)
{
#if FLEXT_SYS == FLEXT_SYS_PD
// for leftmost inlet
class_addbang(c,cb_bang);
if(!dsp) class_addfloat(c,cb_float);
class_addsymbol(c,cb_symbol);
// class_addpointer(c,cb_pointer);
class_addlist(c,cb_anything);
class_addanything(c,cb_anything);
// proxy for extra inlets
if(UNLIKELY(!px_class)) {
// only once
px_class = class_new(gensym(const_cast<char *>(" flext_base proxy ")),NULL,NULL,sizeof(px_object),CLASS_PD|CLASS_NOINLET, A_NULL);
class_addbang(px_class,px_object::px_bang); // for other inlets
class_addfloat(px_class,px_object::px_float); // for other inlets
class_addsymbol(px_class,px_object::px_symbol); // for other inlets
// class_addpointer(px_class,px_object::px_pointer); // for other inlets
class_addlist(px_class,px_object::px_anything); // for other inlets
class_addanything(px_class,px_object::px_anything); // for other inlets
}
#elif FLEXT_SYS == FLEXT_SYS_MAX
addbang((method)cb_bang);
addint((method)cb_int);
addfloat((method)cb_float);
addmess((method)cb_anything,"list",A_GIMME,A_NOTHING); // must be explicitly given, otherwise list elements are distributed over inlets
addmess((method)cb_anything,"anything",A_GIMME,A_NOTHING);
#else
#error Not implemented!
#endif
// setup non-leftmost ints and floats
ADD_PROXYMSG(c,1);
ADD_PROXYMSG(c,2);
ADD_PROXYMSG(c,3);
ADD_PROXYMSG(c,4);
ADD_PROXYMSG(c,5);
ADD_PROXYMSG(c,6);
ADD_PROXYMSG(c,7);
ADD_PROXYMSG(c,8);
ADD_PROXYMSG(c,9);
}
static void openpanel_setup(void)
{
openpanel_class = class_new(gensym("openpanel"),
(t_newmethod)openpanel_new, (t_method)openpanel_free,
sizeof(t_openpanel), 0, 0);
class_addbang(openpanel_class, openpanel_bang);
class_addsymbol(openpanel_class, openpanel_symbol);
class_addmethod(openpanel_class, (t_method)openpanel_callback,
gensym("callback"), A_SYMBOL, 0);
}
static void savepanel_setup(void)
{
savepanel_class = class_new(gensym("savepanel"),
(t_newmethod)savepanel_new, (t_method)savepanel_free,
sizeof(t_savepanel), 0, 0);
class_addbang(savepanel_class, savepanel_bang);
class_addsymbol(savepanel_class, savepanel_symbol);
class_addmethod(savepanel_class, (t_method)savepanel_callback,
gensym("callback"), A_SYMBOL, 0);
}
static void spigot_setup(void)
{
spigot_class = class_new(gensym("spigot"), (t_newmethod)spigot_new, 0,
sizeof(t_spigot), 0, A_DEFSYM, 0);
class_addbang(spigot_class, spigot_bang);
class_addpointer(spigot_class, spigot_pointer);
class_addfloat(spigot_class, spigot_float);
class_addsymbol(spigot_class, spigot_symbol);
class_addlist(spigot_class, spigot_list);
class_addanything(spigot_class, spigot_anything);
}
static void pack_setup(void)
{
pack_class = class_new(gensym("pack"), (t_newmethod)pack_new,
(t_method)pack_free, sizeof(t_pack), 0, A_GIMME, 0);
class_addbang(pack_class, pack_bang);
class_addpointer(pack_class, pack_pointer);
class_addfloat(pack_class, pack_float);
class_addsymbol(pack_class, pack_symbol);
class_addlist(pack_class, pack_list);
class_addanything(pack_class, pack_anything);
}
void bang_setup(void)
{
bang_class = class_new(gensym("bang"), (t_newmethod)bang_new, 0,
sizeof(t_bang), 0, 0);
class_addcreator((t_newmethod)bang_new2, gensym("b"), 0);
class_addbang(bang_class, bang_bang);
class_addfloat(bang_class, bang_bang);
class_addsymbol(bang_class, bang_bang);
class_addlist(bang_class, bang_bang);
class_addanything(bang_class, bang_bang);
}
