Esempio n. 1
0
File: m_class.c Progetto: toto/ipd
    /* this routine is called when a new "object" is requested whose class Pd
    doesn't know.  Pd tries to load it as an extern, then as an abstraction. */
void new_anything(void *dummy, t_symbol *s, int argc, t_atom *argv)
{
    t_pd *current;
    int fd;
    char dirbuf[MAXPDSTRING], *nameptr;
    if (tryingalready) return;
    newest = 0;
    class_loadsym = s;
    if (sys_load_lib(canvas_getcurrent(), s->s_name))
    {
        tryingalready = 1;
        typedmess(dummy, s, argc, argv);
        tryingalready = 0;
        return;
    }
    class_loadsym = 0;
    current = s__X.s_thing;
    if ((fd = canvas_open(canvas_getcurrent(), s->s_name, ".pd",
        dirbuf, &nameptr, MAXPDSTRING, 0)) >= 0 ||
            (fd = canvas_open(canvas_getcurrent(), s->s_name, ".pat",
                dirbuf, &nameptr, MAXPDSTRING, 0)) >= 0)
    {
        close (fd);
        if (!pd_setloadingabstraction(s))
        {
            canvas_setargs(argc, argv);
            binbuf_evalfile(gensym(nameptr), gensym(dirbuf));
            if (s__X.s_thing != current)
                canvas_popabstraction((t_canvas *)(s__X.s_thing));
            canvas_setargs(0, 0);
        }
        else error("%s: can't load abstraction within itself\n", s->s_name);
    }
    else newest = 0;
}
Esempio n. 2
0
void *plustot_var_new(t_symbol *s, int ac, t_atom *av)
{
    t_plustot_var *x = 0;
    t_glist *glist = canvas_getcurrent();
    t_plustin *tin = 0;
    t_plusvar *var = 0;
    if (ac && av->a_type == A_SYMBOL &&
	(tin = plustin_glistprovide(glist, PLUSTIN_GLIST_ANY, 0)) &&
	(var = plusvar_new(av->a_w.w_symbol->s_name, 0, tin)))
    {
	x = (t_plustot_var *)plusobject_new(plustot_var_class, s, ac, av, 0);
	plusbob_preserve((t_plusbob *)var);
	plusbob_setowner((t_plusbob *)var, (t_pd *)x);
	plusvar_setlist(var, ac - 1, av + 1, 1);
	x->x_glist = glist;
	x->x_var = var;
	x->x_proxy = plusproxy_var_new((t_pd *)x);
	plusinlet_new(&x->x_plusobject, (t_pd *)x->x_proxy, 0, 0);
	plusoutlet_new(&x->x_plusobject, &s_symbol);
    }
    else
    {
	if (!ac || av->a_type != A_SYMBOL)
	    loud_error(0, "+var: missing name of a variable");
	else
	    loud_error(0, "+var: cannot initialize");
	if (tin)
	{
	    plusbob_preserve((t_plusbob *)tin);
	    plusbob_release((t_plusbob *)tin);
	}
    }
    return (x);
}
Esempio n. 3
0
    /* this routine is called when a new "object" is requested whose class Pd
    doesn't know.  Pd tries to load it as an extern, then as an abstraction. */
void new_anything(void *dummy, t_symbol *s, int argc, t_atom *argv)
{
    int fd;
    char dirbuf[MAXPDSTRING], classslashclass[MAXPDSTRING], *nameptr;
    if (tryingalready>MAXOBJDEPTH){
      error("maximum object loading depth %d reached", MAXOBJDEPTH);
      return;
    }
    if (s == &s_anything){
      error("object name \"%s\" not allowed", s->s_name);
      return;
    }
    pd_this->pd_newest = 0;
    class_loadsym = s;
    pd_globallock();
    if (sys_load_lib(canvas_getcurrent(), s->s_name))
    {
        tryingalready++;
        typedmess(dummy, s, argc, argv);
        tryingalready--;
        return;
    }
    class_loadsym = 0;
    pd_globalunlock();
}
Esempio n. 4
0
void *hoa_canvas_new(t_symbol *s, long argc, t_atom *argv)
{
    t_atom av[3];
    
    atom_setfloat(av, 0);
	t_hoa_canvas *x = (t_hoa_canvas *)pd_new(hoa_canvas_class);
    t_canvas* owner = canvas_getcurrent();
    x->x_canvas = canvas_new(0, 0, 0, NULL);
    canvas_vis(x->x_canvas, 0);
    pd_typedmess((t_pd *)x->x_canvas, gensym("pop"), 1, av);
    canvas_setcurrent(owner);
    
    if(argc && atom_gettype(argv) == A_SYM)
    {
        
        
        atom_setfloat(av, 0);
        atom_setfloat(av+1, 20);
        atom_setsym(av+2, atom_getsym(argv));
        pd_typedmess((t_pd *)x->x_canvas, gensym("obj"), 3, av);
    }
    
    canvas_loadbang(x->x_canvas);
    canvas_vis(x->x_canvas, 1);
    
    outlet_new((t_object *)x, &s_signal);
    return (x);
}
Esempio n. 5
0
static void *sfread_new(t_floatarg chan,t_floatarg skip)
{
#ifdef ROCKBOX
    (void) skip;
#endif
    t_sfread *x = (t_sfread *)pd_new(sfread_class);
    t_int c = chan;

    x->x_glist = (t_glist*) canvas_getcurrent();

    if (c<1 || c > MAX_CHANS) c = 1;
    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("ft1"));
    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("ft2"));


    x->x_fd = -1;
    x->x_mapaddr = NULL;

    x->x_size = 0;
    x->x_loop = 0;
    x->x_channels = c;
    x->x_mapaddr=NULL;
    x->x_pos = 0;
    x->x_skip = 0;
    x->x_speed = ftofix(1.0);
    x->x_play = 0;

    while (c--) {
	 outlet_new(&x->x_obj, gensym("signal"));
    }

     x->x_bangout = outlet_new(&x->x_obj, &s_float);

    return (x);
}
Esempio n. 6
0
void *plustot_qlist_new(t_symbol *s, int ac, t_atom *av)
{
    t_plustot_qlist *x = 0;
    t_glist *glist = canvas_getcurrent();
    t_plustin *tin = 0;
    t_plustob *tob = 0;
    if ((tin = plustin_glistprovide(glist, PLUSTIN_GLIST_ANY, 0)) &&
	(tob = plustob_new(tin, 0)))
    {
	x = (t_plustot_qlist *)
	    plusobject_new(plustot_qlist_class, s, ac, av, 0);
	plusbob_preserve((t_plusbob *)tob);
	plusbob_setowner((t_plusbob *)tob, (t_pd *)x);
	plustob_setlist(tob, ac, av);
	x->x_glist = glist;
	x->x_tob = tob;
	x->x_proxy = plusproxy_qlist_new(x);
	plusinlet_new(&x->x_plusobject, (t_pd *)x->x_proxy, 0, 0);
	plusoutlet_new(&x->x_plusobject, &s_anything);
	x->x_rightout = outlet_new((t_object *)x, &s_symbol);
    }
    else
    {
	loud_error(0, "+qlist: cannot initialize");
	if (tin)
	{
	    plusbob_preserve((t_plusbob *)tin);
	    plusbob_release((t_plusbob *)tin);
	}
    }
    return (x);
}
Esempio n. 7
0
static void *matrix_new(t_symbol *s, int argc, t_atom *argv)
{
  t_matrix *x = (t_matrix *)pd_new(matrix_class);
  int row, col;


  inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("matrix"), gensym(""));
  outlet_new(&x->x_obj, 0);

  x->atombuffer   = 0;
  x->x_canvas = canvas_getcurrent();

  switch (argc) {
  case 0:
    row = col = 0;
    break;
  case 1:
    if (argv->a_type == A_SYMBOL) {
      matrix_read(x, argv->a_w.w_symbol);
      return(x);
    }
    row = col = atom_getfloat(argv);
    break;
  default:
    row = atom_getfloat(argv++);
    col = atom_getfloat(argv++);
  }

  if(row*col) {
    adjustsize(x, row, col);
    matrix_set(x, 0);
  }

  return (x);
}
Esempio n. 8
0
File: xeq.c Progetto: pure-data/xeq
static void xeq_newbase(t_xeq *x, t_binbuf *bb, t_method tickmethod)
{
    xeq_window_bind(x);
    x->x_tempo = 1;
    x->x_canvas = canvas_getcurrent();
    x->x_whenclockset = 0;
    x->x_clockdelay = 0;
    x->x_clock = tickmethod ? clock_new(x, tickmethod) : 0;
    xeq_noteons_clear(x);
    x->x_ttp = 0;
    x->x_transpo = 0;
    x->x_autoit.i_owner = x;
    x->x_stepit.i_owner = x;
    x->x_walkit.i_owner = x;
    xeq_setbinbuf(x, bb);
    xeqit_sethooks(&x->x_autoit, xeqithook_autodelay, xeqithook_applypp,
		   xeqithook_playmessage, xeqithook_playfinish,
		   xeqithook_loopover);
    xeqit_sethooks(&x->x_stepit, xeqithook_stepdelay, xeqithook_applypp,
		   xeqithook_playmessage, xeqithook_stepfinish, 0);
    xeqit_sethooks(&x->x_walkit, 0, 0, 0, 0, 0);
    xeqit_rewind(&x->x_autoit);
    xeqit_rewind(&x->x_stepit);
    xeqit_rewind(&x->x_walkit);
}
Esempio n. 9
0
bool flext_obj::GetParamSym(t_atom &dst,const t_symbol *sym,t_canvas *c)
{
#if FLEXT_SYS == FLEXT_SYS_PD && defined(PD_MINOR_VERSION) && PD_MINOR_VERSION >= 37
    if(!c) c = canvas_getcurrent();

    const char *s = GetString(sym);
    if((s[0] == '$' || s[0] == '#') && isdigit(s[1])) {
        const t_symbol *res;
        // patcher parameter detected... get value!
        if(s[0] != '$') {
            char tmp[MAXPDSTRING];
            strcpy(tmp,s);
            tmp[0] = '$';
            res = canvas_realizedollar(c,const_cast<t_symbol *>(MakeSymbol(tmp)));
        }
        else
            res = canvas_realizedollar(c,const_cast<t_symbol *>(sym));

        // check for number
        const char *c = GetString(res);
        while(*c && (isdigit(*c) || *c == '.')) ++c;

        if(!*c) 
            SetFloat(dst,(float)atof(GetString(res)));
        else
            SetSymbol(dst,res);
        return true;
    }
    else
#else
    #pragma message("Not implemented")
#endif
    SetSymbol(dst,sym);
    return true;
}
Esempio n. 10
0
static void *hfadl_scale_new(t_symbol *s, int argc, t_atom *argv)
{
  t_hfadl_scale *x = (t_hfadl_scale *)pd_new(hfadl_scale_class);
  
  if((argc >= 1)&&IS_A_FLOAT(argv,0))
  {
    int j, i = (int)atom_getintarg(0, argc, argv);
    
    if(i >= 0)
    {
      j = iemgui_modulo_color(i);
      x->x_gui.x_lcol = my_iemgui_color_hex[j];
    }
    else
    {
      j = -1 - i;
      x->x_gui.x_lcol = ((j & 0x3f000) << 6)|((j & 0xfc0) << 4)|((j & 0x3f) << 2);
    }
  }
  else
    x->x_gui.x_lcol = 0;
  x->x_gui.x_draw = (t_iemfunptr)hfadl_scale_draw;
  x->x_gui.x_glist = (t_glist *)canvas_getcurrent();
  x->x_gui.x_w = 126;
  x->x_gui.x_h = 21;
  strcpy(x->x_gif, my_iemgui_black_hlscale_gif);
  my_iemgui_change_scale_col(x->x_gif, x->x_gui.x_lcol);
  x->x_gui.x_fsf.x_selected = 0;
  return(x);
}
Esempio n. 11
0
static void *scalar_define_new(t_symbol *s, int argc, t_atom *argv)
{
    t_atom a[9];
    t_glist *gl;
    t_canvas *x, *z = canvas_getcurrent();
    t_symbol *templatesym = &s_float, *asym = gensym("#A");
    t_template *template;
Esempio n. 12
0
static void *voutlet_newsig(t_symbol *s)
{
    t_voutlet *x = (t_voutlet *)pd_new(voutlet_class);
    x->x_canvas = canvas_getcurrent();
    x->x_parentoutlet = canvas_addoutlet(x->x_canvas,
        &x->x_obj.ob_pd, &s_signal);
    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
    x->x_endbuf = x->x_buf = (t_sample *)getbytes(0);
    x->x_bufsize = 0;

    resample_init(&x->x_updown);

    /* this should be though over:
     * it might prove hard to provide consistency between labeled up- & downsampling methods
     * maybe indeces would be better...
     *
     * up till now we provide several upsampling methods and 1 single downsampling method (no filtering !)
     */
    if (s == gensym("hold"))x->x_updown.method=1;        /* up: sample and hold */
    else if (s == gensym("lin"))x->x_updown.method=2;    /* up: linear interpolation */
    else if (s == gensym("linear"))x->x_updown.method=2; /* up: linear interpolation */
    else if (s == gensym("pad"))x->x_updown.method=0;    /* up: zero pad */
    else x->x_updown.method=3;                           /* up: zero-padding; down: ignore samples inbetween */

    return (x);
}
Esempio n. 13
0
static void *capture_new(t_symbol *s, t_floatarg f)
{
    t_capture *x = 0;
    float *buffer;
    int bufsize = (int)f;  /* CHECKME */
    if (bufsize <= 0)  /* CHECKME */
        bufsize = CAPTURE_DEFSIZE;
    if (buffer = getbytes(bufsize * sizeof(*buffer)))
    {
        x = (t_capture *)pd_new(capture_class);
        x->x_canvas = canvas_getcurrent();
        if (s && s != &s_)
        {
            if (s == gensym("x"))
                x->x_intmode = 'x';
            else if (s == gensym("m"))
                x->x_intmode = 'm';
            else
                x->x_intmode = 'd';  /* ignore floats */
        }
        x->x_buffer = buffer;
        x->x_bufsize = bufsize;
        outlet_new((t_object *)x, &s_float);
        x->x_filehandle = hammerfile_new((t_pd *)x, 0, 0, capture_writehook, 0);
        capture_clear(x);
    }
    return (x);
}
Esempio n. 14
0
static void *iem_send_kernel_new(void)
{
  t_iem_send_kernel *x = (t_iem_send_kernel *)pd_new(iem_send_kernel_class);
  t_glist *glist = (t_glist *)canvas_getcurrent();
  t_canvas *canvas=glist_getcanvas(glist);
  int ac=0;
  t_atom *av;
  
  canvas_setcurrent(canvas);
  canvas_getargs(&ac, &av);
  canvas_unsetcurrent(canvas);
  
  if(ac > 0)
  {
    if(IS_A_SYMBOL(av,0))
    {
      x->x_sym = atom_getsymbol(av);
    }
    else if(IS_A_FLOAT(av,0))
    {
      char str[100];
      
      sprintf(str, "%g", atom_getfloat(av));
      x->x_sym = gensym(str);
    }
    else
      x->x_sym = 0;
  }
  else
    x->x_sym = 0;
  return (x);
}
Esempio n. 15
0
static void *h_deque_new(t_symbol *s, int argc, t_atom *argv) 
{
  t_h_deque *x = (t_h_deque *)pd_new(h_deque_class);
  t_proxy *inlet = (t_proxy *)pd_new(proxy_class); // for the proxy inlet

  inlet->x = x;	// make x visible to the proxy inlets
  
  switch(argc)
    {
    default:
      post("h_deque warning: only one argument for namespace is possible!");
   case 1:
      x->hdeque = new HDeque(atom_getsymbol(argv)->s_name);
      break;
    case 0:
      x->hdeque = new HDeque();
      break;
    }

  // we are going to create a proxy inlet no. 0
  // it belongs to the object x but the destination is t_proxy
  inlet->index = 0;
  inlet_new(&x->x_obj, &inlet->obj.ob_pd, 0,0);

  x->out0 = outlet_new(&x->x_obj, 0);
  x->out1 = outlet_new(&x->x_obj, &s_float);
  x->out2 = outlet_new(&x->x_obj, &s_bang);
  x->x_canvas = canvas_getcurrent();
    
  return (void *)x;
}
Esempio n. 16
0
static void *namecanvas_new(t_symbol *s)
{
    t_namecanvas *x = (t_namecanvas *)pd_new(namecanvas_class);
    x->x_owner = (t_pd *)canvas_getcurrent();
    x->x_sym = s;
    if (*s->s_name) pd_bind(x->x_owner, s);
    return (x);
}
Esempio n. 17
0
File: sl.c Progetto: Angeldude/pd
static void *lsend_new(t_symbol *s)
{
    t_lsend *x = (t_lsend *)pd_new(lsend_class);
    char mysym[MAXPDSTRING];
    
    sprintf(mysym,"%s%p",s->s_name,canvas_getcurrent());
    x->x_sym = gensym(mysym);
    return (x);
}
Esempio n. 18
0
static void *vinlet_new(t_symbol *s)
{
    t_vinlet *x = (t_vinlet *)pd_new(vinlet_class);
    x->x_canvas = canvas_getcurrent();
    x->x_inlet = canvas_addinlet(x->x_canvas, &x->x_obj.ob_pd, 0);
    x->x_bufsize = 0;
    x->x_buf = 0;
    outlet_new(&x->x_obj, 0);
    return (x);
}
static void *soundfile_info_new(void)
{
  t_soundfile_info *x = (t_soundfile_info *)pd_new(soundfile_info_class);
  
  x->x_size = 10000;
  x->x_begmem = (long *)getbytes(x->x_size * sizeof(long));
  x->x_list_out = outlet_new(&x->x_obj, &s_list);
  x->x_canvas = canvas_getcurrent();
  return (x);
}
Esempio n. 20
0
    /* this routine is called when a new "object" is requested whose class Pd
    doesn't know.  Pd tries to load it as an extern, then as an abstraction. */
void new_anything(void *dummy, t_symbol *s, int argc, t_atom *argv)
{
    t_pd *current;
    int fd;
    char dirbuf[MAXPDSTRING], classslashclass[MAXPDSTRING], *nameptr;
    if (tryingalready>MAXOBJDEPTH){
      error("maximum object loading depth %d reached", MAXOBJDEPTH);
      return;
    }
    newest = 0;
    class_loadsym = s;
    if (sys_load_lib(canvas_getcurrent(), s->s_name))
    {
        tryingalready++;
        typedmess(dummy, s, argc, argv);
        tryingalready--;
        return;
    }
    class_loadsym = 0;
    current = s__X.s_thing;
    /* for class/class.pd support, to match class/class.pd_linux  */
    snprintf(classslashclass, MAXPDSTRING, "%s/%s", s->s_name, s->s_name);
    if ((fd = canvas_open(canvas_getcurrent(), s->s_name, ".pd",
        dirbuf, &nameptr, MAXPDSTRING, 0)) >= 0 ||
            (fd = canvas_open(canvas_getcurrent(), s->s_name, ".pat",
                dirbuf, &nameptr, MAXPDSTRING, 0)) >= 0 ||
               (fd = canvas_open(canvas_getcurrent(), classslashclass, ".pd",
                    dirbuf, &nameptr, MAXPDSTRING, 0)) >= 0)
    {
        close (fd);
        if (!pd_setloadingabstraction(s))
        {
            canvas_setargs(argc, argv);
            binbuf_evalfile(gensym(nameptr), gensym(dirbuf));
            canvas_initbang((t_canvas *)(s__X.s_thing));/* JMZ*/
            if (s__X.s_thing != current)
                canvas_popabstraction((t_canvas *)(s__X.s_thing));
            canvas_setargs(0, 0);
        }
        else error("%s: can't load abstraction within itself\n", s->s_name);
    }
    else newest = 0;
}
Esempio n. 21
0
static void *bitand_new(t_floatarg f1, t_floatarg f2)
{
    t_bitand *x = (t_bitand *)pd_new(bitand_class);
    x->x_glist = canvas_getcurrent();
    x->x_rightinlet = inlet_new((t_object *)x, (t_pd *)x, &s_signal, &s_signal);
    outlet_new((t_object *)x, &s_signal);
    x->x_signalscalar = obj_findsignalscalar(x, 1);
    bitand_intmask(x, f1);
    bitand_mode(x, f2);
    return (x);
}
Esempio n. 22
0
static void *freadln_new(void)
{
   t_freadln *x = (t_freadln *)pd_new(freadln_class);
   x->x_message_outlet = outlet_new(&x->x_ob, &s_list);
   x->x_readybang_outlet = outlet_new(&x->x_ob, &s_bang);
   x->x_filename=0;
   x->x_file=0;
   x->x_textbuf=0;
   x->x_canvas = canvas_getcurrent();
   return (void *)x;
}
Esempio n. 23
0
static void *savepanel_new( void)
{
    char buf[50];
    t_savepanel *x = (t_savepanel *)pd_new(savepanel_class);
    sprintf(buf, "d%lx", (t_int)x);
    x->x_s = gensym(buf);
    x->x_canvas = canvas_getcurrent();
    pd_bind(&x->x_obj.ob_pd, x->x_s);
    outlet_new(&x->x_obj, &s_symbol);
    return (x);
}
Esempio n. 24
0
static void *active_new(void)
{
    t_active *x = (t_active *)pd_new(active_class);
    char buf[32];
    sprintf(buf, ".x%x.c", (int)canvas_getcurrent());
    x->x_cvname = gensym(buf);
    x->x_on = 0;
    outlet_new((t_object *)x, &s_float);
    hammergui_bindfocus((t_pd *)x);
    return (x);
}
Esempio n. 25
0
File: rl.c Progetto: Angeldude/pd
static void *lreceive_new(t_symbol *s)
{
    t_lreceive *x = (t_lreceive *)pd_new(lreceive_class);
    char mysym[MAXPDSTRING];
    
    sprintf(mysym,"%s%p",s->s_name,canvas_getcurrent());
    x->x_sym = gensym(mysym);
    pd_bind(&x->x_obj.ob_pd, x->x_sym);
    outlet_new(&x->x_obj, 0);
    return (x);
}
Esempio n. 26
0
static void *patcherinfos_new(t_symbol *s, int argc, t_atom *argv)
{
    t_patcherinfos *x = (t_patcherinfos *)eobj_new(patcherinfos_class);
    if(x)
    {
        if(canvas_getcurrent())
        {
            x->f_canvas = glist_getcanvas(canvas_getcurrent());
        }
        else
        {
            x->f_canvas = NULL;
        }
        x->f_out_name = outlet_new((t_object *)x, &s_symbol);
        x->f_out_path = outlet_new((t_object *)x, &s_symbol);
        x->f_out_coords = outlet_new((t_object *)x, &s_list);
        x->f_time = clock_getsystime();
    }
    return x;
}
Esempio n. 27
0
/////////////////////////////////////////////////////////
// Constructor
//
/////////////////////////////////////////////////////////
flext_obj :: FLEXT_CLASSDEF(flext_obj)()
    : x_obj(m_holder)
    , clss(m_holdclass)
    , m_name(m_holdname)
{
#if FLEXT_SYS == FLEXT_SYS_PD
    m_canvas = canvas_getcurrent();
#elif FLEXT_SYS == FLEXT_SYS_MAX
    m_canvas = (t_patcher *)sym__shP->s_thing;
    x_obj->curinlet = 0;
#endif
}
Esempio n. 28
0
static void *plusequals_new(t_floatarg f)
{
    t_plusequals *x = (t_plusequals *)pd_new(plusequals_class);
    x->x_sum = f;
    x->x_glist = canvas_getcurrent();
    x->x_triglet = inlet_new((t_object *)x, (t_pd *)x, &s_signal, &s_signal);
    outlet_new((t_object *)x, &s_signal);
    // MAGIC
    x->x_signalscalar = obj_findsignalscalar((t_object *)x, 1);

    return (x);
}
Esempio n. 29
0
static void *iem_event_new(t_symbol *s, int argc, t_atom *argv)
{
  t_iem_event *x = (t_iem_event *)pd_new(iem_event_class);
  t_int w=32, h=32;
  
  x->x_gui.x_snd = gensym("empty");
  x->x_gui.x_rcv = gensym("empty");
  x->x_gui.x_lab = gensym("empty");
  x->x_gui.x_fsf.x_font_style = 0;
  if((argc >= 6)&&IS_A_FLOAT(argv,0)&&IS_A_FLOAT(argv,1)
    &&IS_A_FLOAT(argv,2)&&IS_A_FLOAT(argv,3)
    &&(IS_A_SYMBOL(argv,4)||IS_A_FLOAT(argv,4))
    &&(IS_A_SYMBOL(argv,5)||IS_A_FLOAT(argv,5)))
  {
    w = (int)atom_getintarg(0, argc, argv);
    h = (int)atom_getintarg(1, argc, argv);
    iem_inttosymargs(&x->x_gui.x_isa, atom_getintarg(2, argc, argv));
    iem_inttofstyle(&x->x_gui.x_fsf, atom_getintarg(3, argc, argv));
    iemgui_new_getnames(&x->x_gui, 4, argv);
  }
  else if((argc >= 2)&&IS_A_FLOAT(argv,0)&&IS_A_FLOAT(argv,1))
  {
    w = (int)atom_getintarg(0, argc, argv);
    h = (int)atom_getintarg(1, argc, argv);
  }
  x->x_gui.x_draw = (t_iemfunptr)iem_event_draw;
  x->x_gui.x_fsf.x_snd_able = 1;
  x->x_gui.x_fsf.x_rcv_able = 1;
  x->x_gui.x_glist = (t_glist *)canvas_getcurrent();
  if(!strcmp(x->x_gui.x_snd->s_name, "empty"))
    x->x_gui.x_fsf.x_snd_able = 0;
  if(!strcmp(x->x_gui.x_rcv->s_name, "empty"))
    x->x_gui.x_fsf.x_rcv_able = 0;
  if(x->x_gui.x_fsf.x_rcv_able)
    pd_bind(&x->x_gui.x_obj.ob_pd, x->x_gui.x_rcv);
  if(w < 4)
    w = 4;
  x->x_gui.x_w = w;
  if(h < 4)
    h = 4;
  x->x_gui.x_h = h;
  iemgui_verify_snd_ne_rcv(&x->x_gui);
  outlet_new(&x->x_gui.x_obj, &s_list);
  x->x_mouse_shft_alt = gensym("mouse_shft_alt");
  x->x_dragg_x_y = gensym("dragg_x_y");
  x->x_key = gensym("key");
  x->x_move_x_y = gensym("move_x_y");
  x->x_x = 0;
  x->x_y = 0;
  x->x_doit = 0;
  return (x);
}
Esempio n. 30
0
/////////////////////////////////////////////////////////
//
// CPPExtern
//
/////////////////////////////////////////////////////////
// Constructor
//
/////////////////////////////////////////////////////////
CPPExtern :: CPPExtern()
    : x_obj(m_holder),
      m_objectname(NULL),
      m_canvas(NULL),
      m_endpost(true)
{
    m_canvas = canvas_getcurrent();
    if(m_holdname) {
        m_objectname=gensym(m_holdname);
    } else {
        m_objectname=gensym("unknown Gem object");
    }
}