Max 5 API Reference

jit.kernel.c

/* 
    jit.kernel.c

    Copyright 2001-2005 - Cycling '74
    Joshua Kit Clayton jkc@cycling74.com
    
*/

#include "jit.common.h"
#include "ext_obex.h"
#include "ext_systhread.h"
#include "parallel.h"
#include "jit.altivec.h"
#include "jit.gl.ob3d.internal.h"
#ifndef WIN_VERSION //win_todo
#if !TARGET_RT_MAC_MACHO
#include <InternetConfig.h> 
#endif
#if (TARGET_API_MAC_CARBON) && !TARGET_RT_MAC_MACHO
#include <LaunchServices.h> 
#endif
#endif //WIN_VERSION

#define JIT_QUEUETHROTTLE_DEFAULT 10

#if (TARGET_API_MAC_CARBON)
#define ICFindConfigFile(a,b,c) 0;
#endif

typedef struct _jit_kernel 
{
    t_jit_object    ob; 
} t_jit_kernel;

static void *_jit_kernel_class;
static long _jit_cursor = 1;
long _jit_cord_pattern = 0;
extern long _jit_glerrorcheck;
extern long _jit_glattribpush; 
extern long _jit_glmatrixdebug;
extern char *_jit_version_str;
extern long _jit_nosplash;
extern t_parallel_task *_jit_parallel_task;
extern long _jit_parallel;
extern long _jit_parallelthreads;
extern long _jit_parallelthresh;
extern long _jit_paralleldebug;
extern long _jit_javaload;
extern long _jit_qt_optimize;
extern long _jit_memreg;
t_symbol *_jit_glreadback;
extern t_atom _jit_spigot_cache;
extern long _jit_spigot_cachesize;
extern long _jit_gl_texture_verbose;
long _jit_gl_texture_verbose = false;
extern long _cfm_in_ub;

void jit_kernel_about(t_jit_kernel *x);
void jit_kernel_doabout(t_jit_kernel *x);
#ifndef WIN_VERSION
void jit_kernel_altivec(t_jit_kernel *x, long c);
#endif 
void jit_kernel_pollthrottle(t_jit_kernel *x, long c);
void jit_kernel_queuethrottle(t_jit_kernel *x, long c);
#ifndef WIN_VERSION //win_todo
void jit_kernel_menubar(t_jit_kernel *x, long c);
void jit_kernel_cord_pattern(t_jit_kernel *x, long c);
#endif
void jit_kernel_cursor(t_jit_kernel *x, long c);
void jit_kernel_glerrorcheck(t_jit_kernel *x, long c);
void jit_kernel_glattribpush(t_jit_kernel *x, long c);
void jit_kernel_glmatrixdebug(t_jit_kernel *x, long c);
void jit_kernel_launch_browser(t_jit_kernel *x, t_symbol *s, long argc, t_atom *argv);
void jit_kernel_dolaunch_browser(t_jit_kernel *x, t_symbol *s, long argc, t_atom *argv);
void jit_kernel_html_ref(t_jit_kernel *x, t_symbol *s, long argc, t_atom *argv);
void jit_kernel_dohtml_ref(t_jit_kernel *x, t_symbol *s, long argc, t_atom *argv);
void jit_kernel_postversion(t_jit_kernel *x);
void jit_kernel_dopostversion(t_jit_kernel *x);
void jit_kernel_nosplash(t_jit_kernel *x, long c);
void jit_kernel_parallel(t_jit_kernel *x, long c);
void jit_kernel_parallelthreads(t_jit_kernel *x, long c);
void jit_kernel_parallelthresh(t_jit_kernel *x, long c);
void jit_kernel_paralleldebug(t_jit_kernel *x, long c);
void jit_kernel_javaload(t_jit_kernel *x, long c);
void jit_kernel_javainit(t_jit_kernel *x);
void jit_kernel_qtoptimize(t_jit_kernel *x, long c);
void jit_kernel_memdebug(t_jit_kernel *x, long c);
void jit_kernel_glreadback(t_jit_kernel *x, t_symbol *s);
void jit_kernel_gl_texture_verbose(t_jit_kernel *x, long c);

void *jit_kernel_new(void);
void jit_kernel_free(void);
void jit_kernel_max_tune(t_jit_kernel *x);

long jit_localpath2url(char *input, char *output);
long jit_urlencode(char *input, char *output);

void brag(void *x, short hold);
t_jit_err jit_java_init(void);

void jit_kernel_spigot_clearcache(t_jit_kernel *x);
void jit_kernel_spigot_getcache(t_jit_kernel *x, t_symbol *s);
void jit_kernel_spigot_cache(t_jit_kernel *x, t_symbol *s, long ac, t_atom *av);
void jit_kernel_spigot_cachesize(t_jit_kernel *x, long n);
void jit_kernel_spigot_getcachesize(t_jit_kernel *x, t_symbol *s);
void jit_kernel_spigot_locatecache(t_jit_kernel *x);
void jit_kernel_spigot_purgecache(t_jit_kernel *x);

// probe protos
extern void max_jit_mop_jit_matrix_endprobe(t_object *o);
extern void max_jit_mop_jit_matrix_showprobe();

// classex export
extern void *max_jit_classex_get(void *x);
extern void max_jit_usurp_method(void *x, t_symbol *s, short argc, t_atom *argv);
extern void max_defer_method(void *x, t_symbol *s, long argc, t_atom *argv);

void jit_kernel_init(void)
{
    t_jit_kernel *x;
    
    _jit_kernel_class = jit_class_new("jit_kernel",(method)jit_kernel_new,(method)jit_kernel_free,
        sizeof(t_jit_kernel),A_CANT,0L);
        
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_about,            "about", 0L);
#ifndef WIN_VERSION //not applicable
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_altivec,          "altivec", A_LONG, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_menubar,          "menubar", A_LONG, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_cord_pattern,     "cordpattern", A_LONG, 0L);
    CLASS_METHOD_ATTR_PARSE(_jit_kernel_class, "cordpattern", "undocumented", _jit_sym_long, 0L, "1");
#endif  
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_pollthrottle,     "pollthrottle", A_LONG, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_queuethrottle,    "queuethrottle", A_LONG, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_launch_browser,   "launch_browser", A_GIMME, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_html_ref,         "html_ref", A_GIMME, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_cursor,           "cursor", A_LONG, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_glerrorcheck,     "glerrorcheck", A_LONG, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_glattribpush,     "glattribpush", A_LONG, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_glmatrixdebug,    "glmatrixdebug", A_LONG, 0L);
    CLASS_METHOD_ATTR_PARSE(_jit_kernel_class, "glmatrixdebug", "undocumented", _jit_sym_long, 0L, "1");
    // weak link exports to assist things like sketch image to/frommatrix use zgetfn on gensym("jitter")->s_thing
    jit_class_addmethod(_jit_kernel_class, (method)jit_object_method,           "exp_jit_object_method", A_CANT, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_object_getmethod,        "exp_jit_object_getmethod", A_CANT, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_object_findregistered,   "exp_jit_object_findregistered", A_CANT, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)max_jit_obex_jitob_get,      "exp_max_jit_obex_jitob_get", A_CANT, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)max_jit_method_is_attr,      "exp_max_jit_method_is_attr", A_CANT, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)max_jit_obex_attrlist_get,   "exp_max_jit_obex_attrlist_get", A_CANT, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_mop_ioproc_tosym,        "exp_jit_mop_ioproc_tosym", A_CANT, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)max_jit_classex_get,         "exp_max_jit_classex_get", A_CANT, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)max_jit_usurp_method,        "exp_max_jit_usurp_method", A_CANT, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)max_defer_method,            "exp_max_defer_method", A_CANT, 0L);
    
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_postversion,      "postversion", 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_nosplash,         "nosplash", A_LONG, 0L);
    CLASS_METHOD_ATTR_PARSE(_jit_kernel_class, "nosplash", "undocumented", _jit_sym_long, 0L, "1");
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_parallel,         "parallel", A_LONG, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_parallelthreads,  "parallelthreads", A_LONG, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_parallelthresh,   "parallelthreshold", A_LONG, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_paralleldebug,    "paralleldebug", A_LONG, 0L);
    CLASS_METHOD_ATTR_PARSE(_jit_kernel_class, "paralleldebug", "undocumented", _jit_sym_long, 0L, "1");
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_javaload,         "java", A_LONG, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_javainit,         "javainit", 0L);
    CLASS_METHOD_ATTR_PARSE(_jit_kernel_class, "javainit", "undocumented", _jit_sym_long, 0L, "1");
    // jb added to enable/disable quicktime matrix wrapping optimizations for testing and troubleshooting
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_qtoptimize,       "qtoptimize", A_LONG, 0L);
    CLASS_METHOD_ATTR_PARSE(_jit_kernel_class, "qtoptimize", "undocumented", _jit_sym_long, 0L, "1");
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_qtoptimize,       "qtoptimise", A_LONG, 0L);
    CLASS_METHOD_ATTR_PARSE(_jit_kernel_class, "qtoptimise", "undocumented", _jit_sym_long, 0L, "1");
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_memdebug,         "memdebug", A_LONG, 0L);
    CLASS_METHOD_ATTR_PARSE(_jit_kernel_class, "memdebug", "undocumented", _jit_sym_long, 0L, "1");
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_glreadback,       "glreadback", A_SYM, 0L);
    CLASS_METHOD_ATTR_PARSE(_jit_kernel_class, "glreadback", "undocumented", _jit_sym_long, 0L, "1");
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_gl_texture_verbose,   "texture_verbose", A_LONG, 0L);
    CLASS_METHOD_ATTR_PARSE(_jit_kernel_class, "texture_verbose", "undocumented", _jit_sym_long, 0L, "1");

    // spigot-cache
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_spigot_cache,         "spigot_cache", A_GIMME, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_spigot_getcache,      "spigot_getcache", A_SYM, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_spigot_locatecache,   "spigot_locatecache", 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_spigot_purgecache,    "spigot_purgecache", 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_spigot_cachesize,     "spigot_cachesize", A_LONG, 0L);
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_spigot_getcachesize,  "spigot_getcachesize", A_SYM, 0L);
    // we can leave this undocumented for now /////////////
    jit_class_addmethod(_jit_kernel_class, (method)jit_kernel_spigot_clearcache,    "spigot_clearcache", 0L);
    CLASS_METHOD_ATTR_PARSE(_jit_kernel_class, "spigot_clearcache", "undocumented", _jit_sym_long, 0L, "1");
    ///////////////////////////////////////////////////////

    // probe 
    jit_class_addmethod(_jit_kernel_class, (method)max_jit_mop_jit_matrix_endprobe,     "endprobe", 0L);
    CLASS_METHOD_ATTR_PARSE(_jit_kernel_class, "endprobe", "undocumented", _jit_sym_long, 0L, "1");
    gensym("matrixprobe_show")->s_thing=(void *)max_jit_mop_jit_matrix_showprobe;
        

#ifdef WIN_VERSION
    _jit_glreadback = gensym("ctt");
#else
    {
        long minor_version = 0;
        Gestalt(gestaltSystemVersionMinor, &minor_version);
        if(minor_version >= 6) {
            //_jit_glreadback = gensym("fbo");
            _jit_glreadback = gensym("rtt");
        }
        else {
            _jit_glreadback = gensym("rtt");
        }
    }
//  _jit_glreadback = gensym("fbo"); // need to test fallback cases exhaustively prior to deploying for OS X. 
#endif

    if (x=jit_kernel_new()) {
        if (!_cfm_in_ub||!gensym("jitter")->s_thing) {
            gensym("jit")->s_thing=(t_object *)x;
            gensym("jitter")->s_thing=(t_object *)x;
        } else if (_cfm_in_ub) {
            gensym("jitterCFM")->s_thing=(t_object *)x;
        }
    } else {
        post("couldn't create jit kernel object");
    }
    
    class_register(CLASS_NOBOX, _jit_kernel_class);
}

// goes through the cache log, and "intelligently"
// prunes the cache down to the requested size
void jit_kernel_spigot_purgecache(t_jit_kernel *x)
{
    jit_qt_movie_purgecache();
}

// just kills everything in the folder
void jit_kernel_spigot_clearcache(t_jit_kernel *x)
{
    jit_qt_movie_clearcache();
}

void jit_kernel_spigot_getcache(t_jit_kernel *x, t_symbol *s)
{
    t_atom a;
    short vol;
    char outname[MAX_PATH_CHARS];

    if (s && s->s_thing) {
        vol = jit_qt_movie_getcachepath(0);
        if (!vol)
            strcpy(outname, "moviepath");
        else
            path_topathname(vol, "", outname);
        typedmess(s->s_thing, gensym(outname), 0, NULL);
    }
}

void jit_kernel_spigot_locatecache(t_jit_kernel *x)
{
    short vol;

    vol = jit_qt_movie_getcachepath(0);
    if (!vol)
        jit_object_post((t_object *)x,"spigot~ is caching audio files at the location of the source movie; nothing to locate.");
    else
        jit_qt_movie_locatecache(vol);
}

void jit_kernel_spigot_cache(t_jit_kernel *x, t_symbol *s, long ac, t_atom *av)
{
/*
    0 = next to original movie
    1 = user domain common folder (default)
    2 = system domain common folder
    3 = temporary folder
    sym = path/to/common/folder
*/
    if (ac && av) {
        if (av->a_type == A_SYM) {
            t_symbol *path = jit_atom_getsym(av);
            char outname[MAX_PATH_CHARS];

            // verify valid path
            if (path_topathname(0, path->s_name, outname)) {
                jit_object_error((t_object *)x,"spigot_cache: bad path name as spigot_cache");
            } else {
                if (jit_qt_movie_xml_test_writability(path->s_name) != JIT_ERR_NONE) {
                    jit_object_error((t_object *)x,"spigot_cache: specified directory is write-protected and can't be used");
                } else
                    jit_atom_setsym(&_jit_spigot_cache, path);
            }
        } else {
            long which = jit_atom_getlong(av);
            t_atom old = _jit_spigot_cache;
            short vol;
            
            jit_atom_setlong(&_jit_spigot_cache, CLAMP(which, 0, 3));
            vol = jit_qt_movie_getcachepath(0);
            if (vol) {
                char outname[MAX_PATH_CHARS];
                
                path_topathname(vol, "", outname);
                if (jit_qt_movie_xml_test_writability(outname) != JIT_ERR_NONE) {
                    jit_object_error((t_object *)x,"spigot_cache: specified directory is write-protected and can't be used");
                    _jit_spigot_cache = old;
                }
            }
        }
    }
}

void jit_kernel_spigot_cachesize(t_jit_kernel *x, long n)
{
    if (n < 0)
        _jit_spigot_cachesize = -1;
    else
        _jit_spigot_cachesize = n;

    jit_kernel_spigot_purgecache(x);    
}

void jit_kernel_spigot_getcachesize(t_jit_kernel *x, t_symbol *s)
{
    t_atom a;

    if (s && s->s_thing) {
        jit_atom_setlong(&a, _jit_spigot_cachesize);
        typedmess(s->s_thing, gensym("int"), 1, &a);
    }
}

void jit_kernel_gl_texture_verbose(t_jit_kernel *x, long c)
{
    if (c > 0)
        _jit_gl_texture_verbose = true;
    else
        _jit_gl_texture_verbose = false;
}

void jit_kernel_max_tune(t_jit_kernel *x)
{
    if (gensym("max")->s_thing) {
        t_atom a;
        jit_atom_setlong(&a,2);
        typedmess(gensym("max")->s_thing,gensym("seteventinterval"),1,&a);
        typedmess(gensym("max")->s_thing,gensym("setsleep"),1,&a);
    } else {
        jit_object_error((t_object *)x,"jitter could not find max object");
    }
}

void jit_kernel_about(t_jit_kernel *x)
{   
    defer_medium(x,(method)jit_kernel_doabout,NULL,0,NULL);
}

void jit_kernel_doabout(t_jit_kernel *x)
{
    brag(x,1);
}


#ifndef WIN_VERSION
void jit_kernel_altivec(t_jit_kernel *x, long c)
{
    if (jit_altivec_capable()&&c)
        _jit_altivec = 1;   
    else 
        _jit_altivec = 0;   
}
#endif //WIN_VERSION

void jit_kernel_pollthrottle(t_jit_kernel *x, long c)
{
    t_atom a[1];

    if (c<1) c=1;
    jit_atom_setlong(a,c);
    typedmess(gensym("max")->s_thing,gensym("setpollthrottle"),1,a);
}

void jit_kernel_queuethrottle(t_jit_kernel *x, long c)
{
    t_atom a[1];

    if (c<1) c=1;
    jit_atom_setlong(a,c);
    typedmess(gensym("max")->s_thing,gensym("setqueuethrottle"),1,a);
}

#ifndef WIN_VERSION //win_todo
void jit_kernel_domenubar(t_jit_kernel *x, long c);
void jit_kernel_domenubar(t_jit_kernel *x, long c)
{
    long vis=IsMenuBarVisible();

    if (c&&!vis)
        ShowMenuBar();  
    else if (!c&&vis)
        HideMenuBar();
}

void jit_kernel_menubar(t_jit_kernel *x, long c)
{
    defer_low(x,(method)jit_kernel_domenubar,(t_symbol *)c,0,NULL);
}
#endif

void jit_kernel_docursor(t_jit_kernel *x, long c);
void jit_kernel_docursor(t_jit_kernel *x, long c)
{
    if (c&&!_jit_cursor) {
#ifdef MAC_VERSION
        ShowCursor();
#else
        ShowCursor(TRUE);
#endif
        _jit_cursor=1;
    } else if (!c&&_jit_cursor) {
#ifdef MAC_VERSION
        HideCursor();
#else
        ShowCursor(FALSE);
#endif
        _jit_cursor=0;  
    }
}

void jit_kernel_cursor(t_jit_kernel *x, long c)
{
    defer_low(x,(method)jit_kernel_docursor,(t_symbol *)c,0,NULL);
}

void jit_kernel_cord_pattern(t_jit_kernel *x, long c)
{
    _jit_cord_pattern = c;
}

void jit_kernel_glerrorcheck(t_jit_kernel *x, long c)
{
    _jit_glerrorcheck = c;
}

void jit_kernel_glattribpush(t_jit_kernel *x, long c)
{
    _jit_glattribpush = c;
}

void jit_kernel_glmatrixdebug(t_jit_kernel *x, long c)
{
    _jit_glmatrixdebug = c;
}

void jit_kernel_postversion(t_jit_kernel *x)
{
    defer_low(x,(method)jit_kernel_dopostversion,NULL,0,NULL);
}

void jit_kernel_dopostversion(t_jit_kernel *x)
{
    jit_object_post((t_object *)x,"Jitter version %s", _jit_version_str);
}

void jit_kernel_nosplash(t_jit_kernel *x, long c)
{
    _jit_nosplash = c;
}

void jit_kernel_parallel(t_jit_kernel *x, long c)
{
    _jit_parallel = (c!=0);
}

void jit_kernel_parallelthreads(t_jit_kernel *x, long c)
{
    _jit_parallelthreads = CLIP(c,0,8);
    if (_jit_parallel_task) {
        parallel_task_free(_jit_parallel_task); 
        _jit_parallel_task = NULL;
    }
}

void jit_kernel_parallelthresh(t_jit_kernel *x, long c)
{
    _jit_parallelthresh = MAX(c,1);
}

void jit_kernel_paralleldebug(t_jit_kernel *x, long c)
{
    _jit_paralleldebug = (c!=0);
}

void jit_kernel_javaload(t_jit_kernel *x, long c)
{
    _jit_javaload = c;
}

void jit_kernel_qtoptimize(t_jit_kernel *x, long c)
{
    _jit_qt_optimize = c;
}

void jit_kernel_memdebug(t_jit_kernel *x, long c)
{
    _jit_memreg = c;
}

void jit_kernel_javainit(t_jit_kernel *x)
{
    //defer_low(x,(method)jit_kernel_javainit,0L,0,0L);
    jit_java_init();
}

void jit_kernel_glreadback(t_jit_kernel *x, t_symbol *s)
{
    _jit_glreadback = s;
}

void *jit_kernel_new(void)
{
    t_jit_kernel *x;
    
    x=(t_jit_kernel *)jit_object_alloc(_jit_kernel_class);  

    return x;
}

void jit_kernel_free(void)
{
    //nada
}


void jit_kernel_launch_browser(t_jit_kernel *x, t_symbol *s, long argc, t_atom *argv)
{
    defer(x,(method)jit_kernel_dolaunch_browser,s,argc,argv);
}

void jit_kernel_html_ref(t_jit_kernel *x, t_symbol *s, long argc, t_atom *argv)
{
    defer(x,(method)jit_kernel_dohtml_ref,s,argc,argv);
}

void jit_kernel_dohtml_ref(t_jit_kernel *x, t_symbol *s, long argc, t_atom *argv)
{
    char tmpstr[MAX_PATH_CHARS], outname[MAX_PATH_CHARS];
    t_atom a;
    short path;
    long type;
    long filetype;
    
    if (argc&&argv&&(argv->a_type==A_SYM)) {
        sprintf(tmpstr, "%s.maxref.xml", argv->a_w.w_sym->s_name);
        if ((!locatefile_extended(tmpstr, &path, &type, &filetype, 0L)) &&
            (!path_topathname(path, tmpstr, outname))) {
            atom_setsym(&a, gensym(outname));
            typedmess(gensym("max")->s_thing, gensym("showdoc"), 1, &a);
        } else {
            jit_object_post((t_object *)x,"Jitter could not locate %s.maxref.xml", argv->a_w.w_sym->s_name);
            jit_object_post((t_object *)x,"Please make sure that the xml object ");
            jit_object_post((t_object *)x,"reference is in the Max search path.");
        }
    }
}

#ifdef MAC_VERSION 
void jit_kernel_dolaunch_browser(t_jit_kernel *x, t_symbol *s, long argc, t_atom *argv)
{
    OSStatus err;
    ICInstance inst;
    long startSel;
    long endSel;
    t_symbol *urlsym;
    
    urlsym = jit_atom_getsym(argv);

    if (ICStart==0) {
        jit_object_error((t_object *)x,"InternetConfig could not be loaded");
        return;
    }

    err = ICStart(&inst, '????');          
    if (err == noErr) {
        err = ICFindConfigFile(inst, 0, nil);
        if (err == noErr) {
            startSel = 0;
            endSel = strlen(urlsym->s_name);
            err = ICLaunchURL(inst, "\p", urlsym->s_name,
                    strlen(urlsym->s_name), &startSel, &endSel);
            if (err)
                jit_object_post((t_object *)x,"Jitter could not launch URL. err = %d", err);
        }
        ICStop(inst);
    }
}

#if 0
void jit_kernel_dohtml_ref(t_jit_kernel *x, t_symbol *s, long argc, t_atom *argv)
{
    char tmpstr[MAX_PATH_CHARS],tmpstr2[MAX_PATH_CHARS],outname[MAX_PATH_CHARS];
    t_atom a;
    short path;
    short refnum;
    long type;
    long filetype;
    OSStatus err;
    ICInstance inst;
    long startSel;
    long endSel;
    t_symbol *urlsym;
    
    if (argc&&argv&&(argv->a_type==A_SYM)) {
        
        sprintf(tmpstr, "%s.html", argv->a_w.w_sym->s_name);
        
        if ((!locatefile_extended(tmpstr, &path, &type, &filetype, 0L)) &&
            (!path_topathname(path, tmpstr, outname))) {
            
#if (TARGET_API_MAC_CARBON)
            if ((UInt32)LSOpenCFURLRef!=(UInt32)kUnresolvedCFragSymbolAddress) // OS X version
            {
                FSRef fsRef;
                CFURLRef url = NULL;
        
                err = path_tofsref(path, tmpstr, &fsRef);
                if (!err) 
                {               
                    LSLaunchFSRefSpec inLaunchSpec;
                    FSRef outAppRef;
                    CFURLRef outAppURL;

                    err = LSGetApplicationForInfo(
                            kLSUnknownType,
                            kLSUnknownCreator,
                            CFSTR("html"),
                            kLSRolesViewer,
                            &outAppRef,
                            &outAppURL); 

                    inLaunchSpec.appRef = &outAppRef;
                    inLaunchSpec.numDocs = 1;
                    inLaunchSpec.itemRefs = &fsRef;
                    inLaunchSpec.passThruParams = NULL;
                    inLaunchSpec.launchFlags = kLSLaunchDefaults;
                    inLaunchSpec.asyncRefCon = NULL;

                    err = LSOpenFromRefSpec( &inLaunchSpec, NULL ); 
                    
                    if (err)                
                        jit_object_post((t_object *)x,"Jitter could not launch URL. err = %d", err);

                } else {
                    jit_object_post((t_object *)x,"Jitter could not launch URL. err = %d", err);
                }
            } else {    
#endif          
                jit_localpath2url(outname,tmpstr);
                
                if (ICStart==0) {
                    jit_object_error((t_object *)x,"InternetConfig could not be loaded");
                    return;
                }

                err = ICStart(&inst, '????');          
                if (err == noErr) {
                    err = ICFindConfigFile(inst, 0, nil);
                    if (err == noErr) {
                        startSel = 0;
                        endSel = strlen(tmpstr);
                        err = ICLaunchURL(inst, "\p", tmpstr, strlen(tmpstr), &startSel, &endSel);
                        if (err)
                            jit_object_post((t_object *)x,"Jitter could not launch URL. err = %d", err);
                    }
                    ICStop(inst);
                }
                
#if (TARGET_API_MAC_CARBON)
            }           
#endif

        } else {
            jit_object_post((t_object *)x,"Jitter could not locate %s.html", argv->a_w.w_sym->s_name);
            jit_object_post((t_object *)x,"Please make sure that the html object ");
            jit_object_post((t_object *)x,"reference is in the Max search path.");
        }
    }
}
#endif // 0
#endif //MAC_VERSION

#ifdef WIN_VERSION
void jit_kernel_dolaunch_browser(t_jit_kernel *x, t_symbol *s, long argc, t_atom *argv)
{
    t_symbol *urlsym;
    SHELLEXECUTEINFO shExInfo;

    urlsym = jit_atom_getsym(argv);

    ZeroMemory( &shExInfo, sizeof( SHELLEXECUTEINFO ) );
    shExInfo.cbSize = sizeof( SHELLEXECUTEINFO );
    shExInfo.lpFile = urlsym->s_name; 
    shExInfo.lpVerb = "open"; 
    shExInfo.hwnd = main_get_client();

    if (!ShellExecuteEx( &shExInfo )) {
        jit_object_post((t_object *)x,"Jitter could not launch URL. err = %d", GetLastError());
    }
}

#if 0
void jit_kernel_dohtml_ref(t_jit_kernel *x, t_symbol *s, long argc, t_atom *argv)
{
    char tmpstr[MAX_PATH_CHARS],tmpstr2[MAX_PATH_CHARS],outname[MAX_PATH_CHARS];
    t_atom a;
    short path;
    short refnum;
    long type;
    long filetype;
    
    if (argc&&argv&&(argv->a_type==A_SYM)) {
        
        sprintf(tmpstr, "%s.html", argv->a_w.w_sym->s_name);
        
        if ((!locatefile_extended(tmpstr, &path, &type, &filetype, 0L)) &&
            (!path_topathname(path, tmpstr, outname))) 
        {
            SHELLEXECUTEINFO shExInfo;

            path_nameconform(outname,tmpstr2,PATH_STYLE_NATIVE_WIN,PATH_TYPE_ABSOLUTE);

            ZeroMemory( &shExInfo, sizeof( SHELLEXECUTEINFO ) );
            shExInfo.cbSize = sizeof( SHELLEXECUTEINFO );
            shExInfo.lpFile = tmpstr2; 
            shExInfo.lpVerb = "open"; 
            shExInfo.hwnd = main_get_client();

            if (!ShellExecuteEx( &shExInfo )) {
                jit_object_post((t_object *)x,"Jitter could not launch URL. err = %d", GetLastError());
            }
        } else {
            jit_object_post((t_object *)x,"Jitter could not locate %s.html", argv->a_w.w_sym->s_name);
            jit_object_post((t_object *)x,"Please make sure that the html object ");
            jit_object_post((t_object *)x,"reference is in the Max search path.");
        }
    }
}
#endif // 0
#endif //WIN_VERSION


static Boolean URLUtils_IsDelimiterChar (char theChar);
static Boolean URLUtils_IsDelimiterChar (char theChar)
{
    if ((theChar == '<') || (theChar == '>') || (theChar == '#'))
    return(true);

    return(false);
}

static Boolean URLUtils_IsUnsafeChar (char theChar);
static Boolean URLUtils_IsUnsafeChar (char theChar)
{
    if ((theChar == '{') || (theChar == '}') || (theChar == '|') || (theChar == '\\') || (theChar == '^') ||
    (theChar == '~') || (theChar == '[') || (theChar == ']') || (theChar == '\`') || (theChar == '%') || 
    (theChar == '(') || (theChar == ')'))
    return(true);

    return(false);
}

static Boolean URLUtils_IsEncodableChar (char theChar);
static Boolean URLUtils_IsEncodableChar (char theChar)
{
    // all control characters and high-ASCII characters are encodable
    if ((theChar <= 0x1f) || (theChar >= 0x7f))
    return(true);

    // the space character is encodable
    if (theChar == 0x20)
    return(true);

    // all delimiters are encodable
    if (URLUtils_IsDelimiterChar(theChar))
    return(true);

    // all unsafe characters are encodable
    if (URLUtils_IsUnsafeChar(theChar))
    return(true);

    return(false);
}

long jit_urlencode(char *input, char *output)
{
    char  myChar;
    long  myCount;
    long  myIndex;

    if (!input||!output)
        return -1;

    // traverse the URL, encoding encodable characters as we go
    for (myCount = 0, myIndex = 0; myIndex < (long)strlen(input); myIndex++) {
        if (URLUtils_IsEncodableChar(input[myIndex])) {
            output[myCount + 0] = '%';
            myChar = (input[myIndex] >> 4) & 0x0f;
            output[myCount + 1] = myChar + ((myChar <= 9) ? '0' : ('A' - 10));
            myChar = input[myIndex] & 0x0f;
            output[myCount + 2] = myChar + ((myChar <= 9) ? '0' : ('A' - 10));
            myCount += 3;  
        } else {
            output[myCount] = input[myIndex];
            myCount++;  
        }
    }
    output[myCount] = '\0';

    return 0;
}

#ifdef MAC_VERSION
long jit_localpath2url(char *input, char *output)
{
    char  myChar;
    long  myCount;
    long  myIndex;
    long  netscape=0;
    OSStatus err;
    ICInstance inst;
    ICAttr attr; 
    char buf[4096]; 
    long size=4096;
    long len;
        
    if (!input||!output)
        return -1;

    sprintf(output, "file:///");

    if (ICStart!=0) {
        err = ICStart(&inst, '????');          
        if (err == noErr) {
            err = ICFindConfigFile(inst, 0, nil);
            ICGetPref(inst, "\pHelper�file", &attr, &buf, &size); //kICHelper
            if ((buf[0]=='M')&&(buf[1]=='O')&&(buf[2]=='S')&&(buf[3]=='S')) {
                netscape=1;
            }
            
            ICStop(inst);
        }
    }

    // traverse the URL, encoding encodable characters as we go
    len = strlen(input);
    for (myCount = 8, myIndex = 0; myIndex < len; myIndex++) {
        if (input[myIndex]==':') {
            output[myCount] = '/';
            myCount++;  
        } else if (input[myIndex]=='/') {
            output[myCount + 0] = '%';
            if (netscape) {
                output[myCount + 1] = '3';
                output[myCount + 2] = 'A';
            } else {
                output[myCount + 1] = '2';
                output[myCount + 2] = 'F';
            }
            myCount += 3; 
        } else if (URLUtils_IsEncodableChar(input[myIndex])) {
            output[myCount + 0] = '%';
            myChar = (input[myIndex] >> 4) & 0x0f;
            output[myCount + 1] = myChar + ((myChar <= 9) ? '0' : ('A' - 10));
            myChar = input[myIndex] & 0x0f;
            output[myCount + 2] = myChar + ((myChar <= 9) ? '0' : ('A' - 10));
            myCount += 3;  
        } else {
            output[myCount] = input[myIndex];
            myCount++;  
        }
    }
    output[myCount] = '\0';
    len = strlen(output);

    return 0;
}
#endif //MAC_VERSION

Copyright © 2008, Cycling '74