void ui_preset_interface(t_ui *x) { char filename[MAX_FILENAME_CHARS]; short path; t_fourcc type; t_fourcc filetype = 'JSON'; t_dictionary* d; t_object* p; t_atom a; strncpy_zero(filename, "j.preset_interface.maxpat", MAX_FILENAME_CHARS); locatefile_extended(filename, &path, &type, &filetype, 1); dictionary_read(filename, path, &d); atom_setobj(&a, d); p = (t_object*)object_new_typed(_sym_nobox, _sym_jpatcher, 1, &a); object_attr_setlong(p, _sym_locked, 1); // start out locked object_attr_setchar(p, _sym_enablehscroll, 0); // turn off scroll bars object_attr_setchar(p, _sym_enablevscroll, 0); object_attr_setchar(p, _sym_openinpresentation, 1); object_attr_setchar(p, _sym_toolbarvisible, 0); object_attr_setsym(p, _sym_title, gensym("preset_interface")); object_method_parse(p, _sym_window, "constrain 5 320 179 595", NULL); object_attach_byptr_register(x, p, _sym_nobox); object_method(p, _sym_vis); // "vis" happens immediately, "front" is defer_lowed object_attr_setobj(jpatcher_get_firstview(p), _sym_owner, (t_object*)x); // become the owner OBJ_ATTR_SYM(p, "arguments", 0, gensym((char*)x->modelAddress.c_str())); // the patch needs a [j.interfaceArguments.js] object_method(p, _sym_loadbang); }
t_plugtastic* plugtastic_new() { t_plugtastic* self = (t_plugtastic*)(object_alloc(sPlugtasticClass)); t_atom a; t_class* c; t_object* p; c = class_findbyname(_sym_box, _sym_forward); if (!c) { p = (t_object*)newinstance(_sym_forward, 0, NULL); if (p) { c = class_findbyname(_sym_box, _sym_forward); freeobject(p); p = NULL; } } atom_setsym(&a, GENSYM("plugtastic_extra_toggle")); self->forward = (t_object*)object_new_typed(CLASS_BOX, _sym_forward, 1, &a); self->openSplash = &sPlugtasticSplash; a.a_type = 0; preferences_getatomforkey(GENSYM("plugtastic_splash"), &a); if (a.a_type) *self->openSplash = atom_getlong(&a); return self; }
void scripto_dblclick(t_scripto *x) { if (x->s_patcher) object_method(x->s_patcher, gensym("vis")); else { t_dictionary *d = dictionary_new(); char parsebuf[256]; t_atom a; long ac = 0; t_atom *av = NULL; // create a patcher without scroll bars and a toolbar sprintf(parsebuf,"@defrect 0 0 300 400 @title scripto @enablehscroll 0 @enablevscroll 0 @presentation 0 @toolbarid \"\""); atom_setparse(&ac,&av,parsebuf); attr_args_dictionary(d,ac,av); atom_setobj(&a,d); sysmem_freeptr(av); x->s_patcher = (t_object *)object_new_typed(CLASS_NOBOX,gensym("jpatcher"),1, &a); freeobject((t_object *)d); // we created this dictionary and we don't need it anymore object_method(x->s_patcher,gensym("vis")); x->s_ui = newobject_sprintf(x->s_patcher, "@maxclass scripto_ui @patching_rect 0 0 300 400 @oncolor %.2f %.2f %.2f %.2f @offcolor %.2f %.2f %.2f %.2f", x->s_oncolor.red, x->s_oncolor.green, x->s_oncolor.blue, x->s_oncolor.alpha, x->s_offcolor.red, x->s_offcolor.green, x->s_offcolor.blue, x->s_offcolor.alpha); object_attach_byptr_register(x, x->s_ui, CLASS_BOX); // attach our UI object to us object_attach_byptr_register(x, x->s_patcher, CLASS_NOBOX); // attach our UI object to us } }
t_max_err db_open(t_symbol *dbname, const char *filename, t_database **db) { long ac=0; t_atom av[6]; if (*db) object_free(*db); if (filename) { atom_setsym(av+ac, gensym("@rambased")); ac++; atom_setlong(av+ac, 0); ac++; atom_setsym(av+ac, gensym("@filename")); ac++; atom_setsym(av+ac, gensym((char*)filename)); ac++; } atom_setsym(av+ac, gensym("@db")); ac++; atom_setsym(av+ac, dbname); ac++; *db = (t_database*)object_new_typed(_sym_nobox, _sym_sqlite, ac, av); if (!*db) return MAX_ERR_GENERIC; return MAX_ERR_NONE; }
// Load an external for internal use t_max_err loadextern(t_symbol *objectname, long argc, t_atom *argv, t_object **object) { t_class *c = NULL; t_object *p = NULL; c = class_findbyname(_sym_box, objectname); if (!c) { p = (t_object*)newinstance(objectname, 0, NULL); if(p){ c = class_findbyname(_sym_box, objectname); freeobject(p); p = NULL; } else{ error("could not load extern (%s) within the oscar extension", objectname->s_name); return MAX_ERR_GENERIC; } } if (*object != NULL) { // if there was an object set previously, free it first... object_free(*object); *object = NULL; } *object = (t_object*)object_new_typed(_sym_box, objectname, argc, argv); return MAX_ERR_NONE; }
// Load an external for internal use // returns true if successful bool jamoma_loadextern(t_symbol *objectname, long argc, t_atom *argv, t_object **object) { t_class *c = NULL; t_object *p = NULL; c = class_findbyname(jps_box, objectname); if (!c) { p = (t_object *)newinstance(objectname, 0, NULL); if (p) { c = class_findbyname(jps_box, objectname); freeobject(p); p = NULL; } else { error("jamoma: could not load extern (%s) within the core", objectname->s_name); return false; } } if (*object != NULL) { // if there was an object set previously, free it first... object_free(*object); *object = NULL; } *object = (t_object *)object_new_typed(CLASS_BOX, objectname, argc, argv); return true; }
// Create void *receive_new(t_symbol *s, long argc, t_atom *argv) { long attrstart = attr_args_offset(argc, argv); // support normal arguments t_receive *x = (t_receive *)object_alloc(s_receive_class); if (x) { object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x, NULL)); x->outlet = outlet_new(x, NULL); if (!g_receivemaster_object) g_receivemaster_object = (t_object *)object_new_typed(CLASS_NOBOX, SymbolGen("jcom.receivemaster"), 0, NULL); x->callback = NULL; x->attr_name = NULL; // attr_args_process(x, argc, argv); // handle attribute args // If no name was specified as an attribute if (x->attr_name == NULL) { if (attrstart > 0) x->attr_name = atom_getsym(argv); else x->attr_name = SymbolGen("jcom.receive no arg specified"); receive_bind(x); } } return x; }
// Entry void ext_main(void *r) { common_symbols_init(); testmaster_classinit(); testrunner_classinit(); testunit_classinit(); testdb_classinit(); testport_classinit(); testassert_classinit(); testequals_classinit(); testlog_classinit(); testterminate_classinit(); testsample_classinit(); ps_testmaster = gensym("test.master"); ps_testport = gensym("test.port"); ps_testmaster->s_thing = (t_object*)object_new_typed(_sym_nobox, ps_testmaster, 0, NULL); defer_low(ps_testmaster->s_thing, (method)deferred_startup, NULL, 0, NULL); quittask_install((method)testmaster_quittask, NULL); object_method(gensym("max")->s_thing, gensym("setmirrortoconsole"), 1); }
void *hoa_dac_new(t_symbol *s, int argc, t_atom *argv) { int i, j, count = 0; t_hoa_dac *x; t_atom channels[512]; int min, max; int symPrepend = 0; x = (t_hoa_dac *)object_alloc(hoa_dac_class); if (argc && atom_gettype(argv) == A_SYM) { char *dac_bus_name = atom_getsym(argv)->s_name; if (isalpha(dac_bus_name[0])) // only works if the first letter isn't a number { symPrepend = 1; atom_setsym(channels, atom_getsym(argv)); } } for(i = 0; i < (argc-symPrepend); i++) { if(atom_gettype(argv+i+symPrepend) == A_SYM) { min = atoi(atom_getsym(argv+i+symPrepend)->s_name); if (min < 10) max = atoi(atom_getsym(argv+i+symPrepend)->s_name+2); else if (min < 100) max = atoi(atom_getsym(argv+i+symPrepend)->s_name+3); else if (min < 1000) max = atoi(atom_getsym(argv+i+symPrepend)->s_name+4); else max = atoi(atom_getsym(argv+i+symPrepend)->s_name+5); if (max > min) { for(j = min; j <= max; j++) { atom_setlong(channels + symPrepend + count++, j); } } else { for(j = min; j >= max; j--) { atom_setlong(channels + symPrepend + count++, j); } } } else if(atom_gettype(argv + symPrepend + i) == A_LONG) { atom_setlong(channels + symPrepend + count++, atom_getlong(argv + symPrepend + i)); } } x->f_number_of_channels = count; dsp_setup((t_pxobject *)x, x->f_number_of_channels); x->f_dac = (t_object *)object_new_typed(CLASS_BOX, gensym("dac~"), count + symPrepend, channels); return x; }
void *record_new(t_symbol *s, int argc, t_atom *argv) { // @arg 0 @ambisonic-order @optional 0 @type int @digest The ambisonic order // @description The ambisonic order, must be at least equal to 1 t_object *x; t_atom arguments[2]; int order = 1; if(atom_gettype(argv) == A_LONG) order = atom_getlong(argv); else if(atom_gettype(argv) == A_FLOAT) order = atom_getfloat(argv); if(order < 1) order = 1; int is2D = 1; if (s == gensym("hoa.3d.record~")) is2D = 0; int number_of_channels = is2D ? (order * 2 + 1) : ( (order+1)*(order+1) ); atom_setlong(arguments, number_of_channels); switch (number_of_channels) { case 9: atom_setlong(arguments+1, 181440); break; case 10: atom_setlong(arguments+1, 20160); break; case 11: atom_setlong(arguments+1, 221760); break; case 12: atom_setlong(arguments+1, 60480); break; case 13: atom_setlong(arguments+1, 262080); break; case 14: atom_setlong(arguments+1, 20160); break; case 15: atom_setlong(arguments+1, 60480); break; case 16: atom_setlong(arguments+1, 40320); break; default: atom_setlong(arguments+1, 20160); break; } x = (t_object *)object_new_typed(CLASS_BOX, gensym("sfrecord~"), 2, arguments); return x; }
void hoa_print_credit() { if(gensym("hoa_print_credits")->s_thing == NULL) { t_object* print; t_atom* sym = (t_atom*) malloc( sizeof(t_atom)); atom_setsym(sym, gensym("HoaLibrary")); print = (t_object*)object_new_typed(CLASS_BOX, gensym("print"), 1, sym); atom_setsym(sym, _sym_credit_line1); object_method_typed(print, gensym("list"), 1, sym, NULL); atom_setsym(sym, _sym_hoa_version); print = (t_object*)object_new_typed(CLASS_BOX, gensym("print"), 1, sym); atom_setsym(sym, _sym_credit_line2); object_method_typed(print, gensym("list"), 1, sym, NULL); gensym("hoa_print_credits")->s_thing = print; freeobject(print); free(sym); } }
void *folder_new(t_symbol *msg, short argc, t_atom *argv) { t_folder *x = (t_folder *)object_alloc(s_folder_class);; if(x){ object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x,NULL)); #ifdef MAC_VERSION x->applescript = (t_object*)object_new_typed(_sym_box, gensym("tap.applescript"), 0, NULL); #endif attr_args_process(x,argc,argv); } return (x); }
void deferred_startup(void) { t_atom a[2]; atom_setlong(a+0, g_port_send); atom_setlong(a+1, g_port_listen); // cannot load classes from disk at the time that the extensions folder is processed ps_testport->s_thing = (t_object*)object_new_typed(_sym_nobox, ps_testport, 2, a); // notify anyone who is listening (e.g. a ruby script that launched max) that we are ready object_method(ps_testport->s_thing, _sym_send, gensym("/testport/ready"), 0, NULL); }
t_max_err db_open(t_symbol *dbname, const char *fullpath, t_database **db) { long ac=0; t_atom av[6]; if (*db) object_free(*db); if (fullpath) { char coercedpath[MAX_PATH_CHARS]; short err; char dbpath[MAX_PATH_CHARS]; #ifdef MAC_VERSION char *temppath; #endif err = path_nameconform((char*)fullpath, coercedpath, PATH_STYLE_NATIVE_PLAT, PATH_TYPE_ABSOLUTE); if (err) strncpy_zero(coercedpath, fullpath, MAX_PATH_CHARS); #ifdef MAC_VERSION temppath = strchr(coercedpath, ':'); *temppath = '\0'; temppath += 1; // at this point temppath points to the path after the volume, and coercedpath has the volume snprintf(dbpath, MAX_PATH_CHARS, "/Volumes/%s%s", coercedpath, temppath); #else // WIN_VERSION strncpy_zero(dbpath, coercedpath, MAX_PATH_CHARS); #endif atom_setsym(av+ac, gensym("@rambased")); ac++; atom_setlong(av+ac, 0); ac++; atom_setsym(av+ac, gensym("@filename")); ac++; atom_setsym(av+ac, gensym(dbpath)); ac++; } atom_setsym(av+ac, gensym("@db")); ac++; atom_setsym(av+ac, dbname); ac++; *db = (t_database*)object_new_typed(_sym_nobox, _sym_sqlite, ac, av); if (!*db) return MAX_ERR_GENERIC; return MAX_ERR_NONE; }
void ep_print_credit() { if(gensym("ep_print_credits")->s_thing == NULL) { t_object* print; t_atom* sym = (t_atom*) malloc( sizeof(t_atom)); atom_setsym(sym, gensym("EpLib Beta 0.1")); print = (t_object*)object_new_typed(CLASS_BOX, gensym("print"), 1, sym); atom_setsym(sym, gensym("Copyright \u00a9 2014, Eliott Paris")); object_method_typed(print, gensym("list"), 1, sym, NULL); gensym("hoa_print_credits")->s_thing = print; freeobject(print); free(sym); } }
void return_makesend(t_return *x) { t_atom a; char osc[512]; t_symbol* module_name = object_attr_getsym(x->common.hub, _sym_name); if (module_name && module_name != _sym_nothing) { strcpy(osc, module_name->s_name); strcat(osc, "/"); strcat(osc, x->common.attr_name->s_name); atom_setsym(&a, gensym(osc)); x->send = (t_object*)object_new_typed(_sym_box, jps_jcom_send, 1, &a); } else defer_low(x, (method)return_makesend, 0, 0, 0); }
void *play_new(t_symbol *s, int argc, t_atom *argv) { // @arg 0 @ambisonic-order @optional 0 @type int @digest The ambisonic order // @description The ambisonic order, must be at least equal to 1 t_atom arguments[1]; ulong order = 1; ulong channels = 1; if(atom_isNumber(argv)) order = max<ulong>(atom_getlong(argv), 1); if (s == gensym("hoa.play~") || s == gensym("hoa.2d.play~")) channels = order * 2 + 1; else if (s == gensym("hoa.3d.play~")) channels = (order+1) * (order+1); return object_new_typed(CLASS_BOX, gensym("sfplay~"), 1, arguments); }
void *NewObj(t_symbol *s, long argc, t_atom *argv){ OBJECT *x = NULL; x = (OBJECT *)object_alloc(g_class); if (x != NULL){ dsp_setup ((t_pxobject *)x, 0); outlet_new((t_pxobject *)x, "signal"); x -> glitched = true; coreobject = (t_object *)object_new_typed(CLASS_NOBOX, gensym("__ray.sniff~_core__"), argc, argv); } else post("Can't Allocate Object"); return x; }
void *hoa_dac_new(t_symbol *s, int argc, t_atom *argv) { // @arg 0 @name outputs @optional 1 @type int/symbol @digest Output routing or/and bus name // @description You can create a <o>hoa.dac~</o> object that uses one or more audio output channel numbers between 1 and 512. These numbers refer to logical channels and can be dynamically reassigned to physical device channels of a particular driver using either the Audio Status window, its I/O Mappings subwindow, or an adstatus object with an output keyword argument. Arguments, If the computer's built-in audio hardware is being used, there will be two input channels available. Other audio drivers and/or devices may have more than two channels. If no argument is typed in, dac~ will have two inlets, for input channels 1 and 2. // If a symbol is provided as the first argument to a dac~ object, then it will get an independent control section in the Max mixer. If two dac~ instances in a patcher hierarchy have the same name they will be on the same "bus" and share controls. int i, j, count = 0; t_hoa_dac *x; t_atom channels[512]; int min, max; int symPrepend = 0; x = (t_hoa_dac *)object_alloc(hoa_dac_class); if (x) { if (argc && atom_gettype(argv) == A_SYM) { char *dac_bus_name = atom_getsym(argv)->s_name; if (isalpha(dac_bus_name[0])) // only works if the first letter isn't a number { symPrepend = 1; atom_setsym(channels, atom_getsym(argv)); } } for(i = 0; i < (argc-symPrepend); i++) { if(atom_gettype(argv+i+symPrepend) == A_SYM) { min = atoi(atom_getsym(argv+i+symPrepend)->s_name); if (min < 10) max = atoi(atom_getsym(argv+i+symPrepend)->s_name+2); else if (min < 100) max = atoi(atom_getsym(argv+i+symPrepend)->s_name+3); else if (min < 1000) max = atoi(atom_getsym(argv+i+symPrepend)->s_name+4); else max = atoi(atom_getsym(argv+i+symPrepend)->s_name+5); if (max > min) { for(j = min; j <= max; j++) { atom_setlong(channels + symPrepend + count++, j); } } else { for(j = min; j >= max; j--) { atom_setlong(channels + symPrepend + count++, j); } } } else if(atom_gettype(argv + symPrepend + i) == A_LONG) { atom_setlong(channels + symPrepend + count++, atom_getlong(argv + symPrepend + i)); } } x->f_number_of_channels = count; dsp_setup((t_pxobject *)x, x->f_number_of_channels); x->f_dac = (t_object *)object_new_typed(CLASS_BOX, gensym("dac~"), count + symPrepend, channels); } return x->f_dac; //return x; }
void *hub_new(t_symbol *s, long argc, t_atom *argv) { short i; long attrstart = attr_args_offset(argc, argv); t_hub *x = (t_hub *)object_alloc(s_hub_class); t_symbol *name = _sym_nothing; t_atom a[2]; if(attrstart && argv) atom_arg_getsym(&name, 0, attrstart, argv); else{ t_object* patcher = jamoma_object_getpatcher((t_object*)x); t_symbol* filepath = object_attr_getsym(patcher, _sym_filepath); char pathstr[MAX_PATH_CHARS]; char* filename = 0; strncpy_zero(pathstr, filepath->s_name, MAX_PATH_CHARS); filename = strrchr(pathstr, '.'); if(filename) { *filename = 0; // strip the suffix by setting '.' to terminating NULL char filename = strrchr(pathstr, '/'); if (filename) { // Our module name is the patchers name since the patcher is typically located // at /some/where/nameToUseForModule.maxpat filename++; // get rid of slash name = gensym(filename); } else name = gensym(pathstr); } else { // We are an unnamed jcom.hub inserted into an unsaved max patcher which has // no '.' in it's filename. Just leave as untitled, at least until it is saved. name = gensym("Untitled"); } } if(x){ for(i=k_num_outlets; i > 0; i--) x->outlets[i-1] = outlet_new(x, 0); object_obex_store((void *)x, _sym_dumpout, (t_object *)x->outlets[k_outlet_dumpout]); x->init_qelem = qelem_new(x, (method)hub_qfn_init); // set default attributes x->attr_name = name; x->osc_name = _sym_nothing; x->attr_type = jps_control; x->attr_description = _sym_nothing; x->attr_algorithm_type = jps_default; // poly for audio, jitter for video, control for control x->attr_size = jps_1U_half; x->attr_inspector = 0; x->using_wildcard = false; x->in_object = NULL; // module MUST have a jcom.in object x->out_object = NULL; // the jcom.out object is optional x->gui_object = NULL; // jcom.remote in the gui x->num_parameters = 0; for(i=0; i<MAX_NUM_CHANNELS; i++) x->meter_object[i] = NULL; x->preset = new presetList; // begin with no presets x->subscriber = new subscriberList; // ... and no subscribers attr_args_process(x, argc, argv); // handle attribute args x->jcom_send = NULL; x->jcom_receive = NULL; atom_setsym(a, jps_jcom_remote_fromModule); x->jcom_send = (t_object*)object_new_typed(_sym_box, jps_jcom_send, 1, a); atom_setsym(a, jps_jcom_remote_toModule); x->jcom_receive = (t_object*)object_new_typed(_sym_box, jps_jcom_receive, 1, a); object_method(x->jcom_receive, jps_setcallback, &hub_receive_callback, x); if(!g_jcom_send_notifications){ atom_setsym(a, gensym("notifications")); g_jcom_send_notifications = (t_object*)object_new_typed(_sym_box, jps_jcom_send, 1, a); } x->container = jamoma_object_getpatcher((t_object*)x); // The following must be deferred because we have to interrogate our box, // and our box is not yet valid until we have finished instantiating the object. // Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6) defer_low(x, (method)hub_examine_context, 0, 0, 0); } return x; }
void filecontainer_doopen(t_filecontainer *x, t_symbol *arg) { t_atom a[4]; int err = 0; char filename[256]; short path; t_fourcc outtype = 0; t_fourcc type = 'cO0p'; #ifdef MAC_VERSION char *temppath; FSRef ref; Boolean isDir; FSCatalogInfo catalogInfo; #else // WIN_VERSION char temppath[512]; #endif char fullpath[512]; t_object *result = NULL; t_object *result2 = NULL; char **record = NULL; // sqlite records char **record2 = NULL; // sqlite records t_filehandle file_handle; t_ptr_size len = 0; char *blob; char sql[512]; if(!arg || !arg->s_name[0]) { if(open_dialog(filename, &path, &outtype, NULL, -1)) // Returns 0 if successful return; } else { t_fourcc typelist[1]; typelist[0] = 'cO0p'; strcpy(filename, arg->s_name); path = 0; locatefile_extended(filename, &path, &type, typelist, 0); } path_topotentialname(path, filename, fullpath, 0); #ifdef MAC_VERSION temppath = strchr(fullpath, ':'); temppath += 1; #else // WIN_VERSION path_nameconform(fullpath, temppath, PATH_STYLE_NATIVE_WIN, PATH_TYPE_ABSOLUTE); #endif x->name = gensym(temppath); // Create our temp folder for extracted files filecontainer_gettemppath(x); // Create the SQLite instance atom_setsym(&a[0], gensym("@rambased")); atom_setlong(&a[1], 0); atom_setsym(&a[2], gensym("@db")); atom_setsym(&a[3], x->name); x->sqlite = object_new_typed(CLASS_NOBOX, _sym_sqlite, 4, a); // Operate on the open DB if(x->sqlite) { object_method(x->sqlite, ps_starttransaction); object_method(x->sqlite, _sym_execstring, TABLEDEF_FILES, NULL); object_method(x->sqlite, _sym_execstring, TABLEDEF_ATTRS, NULL); object_method(x->sqlite, _sym_execstring, "UPDATE files SET valid = 1", NULL); object_method(x->sqlite, _sym_execstring, "SELECT file_id, filename, moddate FROM files", &result); while(record = (char **)object_method(result, _sym_nextrecord)) { // Here we check for the optional 'platform' attr for this file. // If a flag exists for the other platform, but not for the current platform, then we ignore this file. #ifdef MAC_VERSION sprintf(sql, "SELECT file_id_ext FROM attrs \ WHERE attr_name = 'platform' AND attr_value = 'windows' AND file_id_ext = %s ", record[0]); object_method(x->sqlite, _sym_execstring, sql, &result2); record2 = (char **)object_method(result2, _sym_nextrecord); if(record2) { sprintf(sql, "SELECT file_id_ext FROM attrs \ WHERE attr_name = 'platform' AND attr_value = 'mac' AND file_id_ext = %s ", record[0]); object_method(x->sqlite, _sym_execstring, sql, &result2); record2 = (char **)object_method(result2, _sym_nextrecord); if(!record2) { sprintf(sql, "UPDATE files SET valid = 0 WHERE file_id = %s ", record[0]); object_method(x->sqlite, _sym_execstring, sql, NULL); continue; } } #else // WIN_VERSION snprintf(sql, 512, "SELECT file_id_ext FROM attrs \ WHERE attr_name = 'platform' AND attr_value = 'mac' AND file_id_ext = %s ", record[0]); object_method(x->sqlite, _sym_execstring, sql, &result2); record2 = (char **)object_method(result2, _sym_nextrecord); if(record2) { snprintf(sql, 512, "SELECT file_id_ext FROM attrs \ WHERE attr_name = 'platform' AND attr_value = 'windows' AND file_id_ext = %s ", record[0]); object_method(x->sqlite, _sym_execstring, sql, &result2); record2 = (char **)object_method(result2, _sym_nextrecord); if(!record2) { snprintf(sql, 512, "UPDATE files SET valid = 0 WHERE file_id = %s ", record[0]); object_method(x->sqlite, _sym_execstring, sql, NULL); continue; } } #endif // At this point we have a file (record[0]), and we have determined that it is indeed a file we want to cache // So cache it to a new file in our temp path err = path_createsysfile(record[1], x->temp_path, type, &file_handle); if(err) { // Handle any errors that occur object_error((t_object *)x, "%s - error %d creating file", filename, err); } else { snprintf(sql, 512, "SELECT content FROM files WHERE file_id = %s", record[0]); object_method(x->sqlite, ps_getblob, sql, &blob, &len); err = sysfile_write(file_handle, &len, blob); if(err) { object_error((t_object *)x, "sysfile_write error (%d)", err); } } err = sysfile_seteof(file_handle, len); if(err) { object_error((t_object *)x, "%s - error %d setting EOF", filename, err); } sysfile_close(file_handle); // close file reference sysmem_freeptr(blob); blob = NULL; // Set the moddate #ifdef MAC_VERSION // FSCatalogInfo catalogInfo; // Boolean status; CFGregorianDate gdate; CFAbsoluteTime abstime; CFTimeZoneRef tz; UTCDateTime utc; sscanf(record[2], "%4ld-%02hd-%02hd %02hd:%02hd:%02lf", &gdate.year, (signed short*)&gdate.month, (signed short*)&gdate.day, (signed short*)&gdate.hour, (signed short*)&gdate.minute, &gdate.second); tz = CFTimeZoneCopySystem(); abstime = CFGregorianDateGetAbsoluteTime(gdate, tz); UCConvertCFAbsoluteTimeToUTCDateTime(abstime, &utc); catalogInfo.contentModDate = utc; strcpy(s_tempstr, x->temp_fullpath->s_name); temppath = strchr(s_tempstr, ':'); temppath++; strcat(temppath, "/"); strcat(temppath, record[1]); FSPathMakeRef((UInt8*)temppath, &ref, &isDir); err = FSSetCatalogInfo(&ref, kFSCatInfoContentMod, &catalogInfo); #else // WIN_VERSION char winpath[512]; HANDLE hFile; FILETIME fileTime; SYSTEMTIME systemTime; sscanf(record[2], "%4lu-%02lu-%02lu %02lu:%02lu:%02lu", &systemTime.wYear, &systemTime.wMonth, &systemTime.wDay, &systemTime.wHour, &systemTime.wMinute, &systemTime.wSecond); err = SystemTimeToFileTime(&systemTime, &fileTime); strcpy(s_tempstr, x->temp_fullpath->s_name); path_nameconform(s_tempstr, winpath, PATH_STYLE_NATIVE_WIN, PATH_TYPE_ABSOLUTE); strcat(winpath, "\\"); strcat(winpath, record[1]); hFile = CreateFile((LPCSTR)winpath , GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); if(hFile == INVALID_HANDLE_VALUE) { object_error((t_object *)x, "invalid handle value"); goto out; } err = SetFileTime(hFile, &fileTime, &fileTime, &fileTime); if(err == 0) { err = GetLastError(); object_error((t_object *)x, "Error setting date: %i", err); } CloseHandle(hFile); out: ; #endif } object_method(x->sqlite, ps_endtransaction); }
int main(void) { common_symbols_init(); PlugtasticInit(); plugtastic_classinit(); sPlugtasticObject = (t_object*)plugtastic_new(); ps_plugtastic = GENSYM("plugtastic"); ps_plugtastic->s_thing = sPlugtasticObject; sMaxObject = _sym_max->s_thing; ps_objectfile = GENSYM("objectfile"); ps_db_object_addinternal = GENSYM("db.object_addinternal"); ps_oblist = GENSYM("oblist"); ps_db_addmetadata = GENSYM("db.addmetadata"); //defer_low(sMaxObject, (method)plug_setup_db, NULL, 0, NULL); plug_setup_db(); post("Plugtastic Version %s | 74Objects.com", PLUGTASTIC_VERSION); // This tells Max 5.0.6 and higher that we want the patcher files to be saved such that they are sorted. // Having the saved this way makes our SVN diffs much more meaningful. object_method_long(sMaxObject, GENSYM("sortpatcherdictonsave"), 1, NULL); // This tells Max 4.5.7 and higher to take any posts to the Max window and also make the // post to the system console, which greatly aids in debugging problems and crashes object_method_long(sMaxObject, GENSYM("setmirrortoconsole"), 1, NULL); // OPEN THE SPLASH if (sPlugtasticSplash) { char name[MAX_FILENAME_CHARS]; short path = 0; long type = 0; long typelist[2] = {'JSON', 'TEXT'}; short err; t_dictionary* d; t_object* p; t_atom a[2]; strncpy_zero(name, "Plugtastic.maxpat", MAX_FILENAME_CHARS); err = locatefile_extended(name, &path, &type, typelist, 2); dictionary_read(name, path, &d); atom_setobj(a, d); p = (t_object*)object_new_typed(_sym_nobox, _sym_jpatcher, 1, a); object_attr_setlong(p, _sym_locked, 1); // start out locked object_attr_setchar(p, _sym_enablehscroll, 0); // turn off scroll bars object_attr_setchar(p, _sym_enablevscroll, 0); object_attr_setchar(p, _sym_toolbarvisible, 0); object_attr_setsym(p, _sym_title, gensym("Welcome to Plugtastic")); object_attr_setparse(p, _sym_rect, "271 170 799 489"); object_attr_setparse(p, _sym_defrect, "271 170 799 489"); object_method(p, _sym_vis); // "vis" happens immediately, "front" is defer_lowed object_method(p, _sym_loadbang); // object_method_parse(p, _sym_window, "constrain 799 489 799 489", NULL); object_method_parse(p, _sym_window, "flags nozoom", NULL); object_method_parse(p, _sym_window, "flags nogrow", NULL); object_method_parse(p, _sym_window, "exec", NULL); } return 0; }