reorganized

svn path=/trunk/; revision=9400

1 files changed, 353 insertions, 0 deletions

diff --git a/desiredata/src/desire.h b/desiredata/src/desire.h
new file mode 100644
index 00000000..f3cefe02
--- /dev/null
+++ b/desiredata/src/desire.h
@@ -0,0 +1,353 @@
+/*
+  This file is part of PureData
+  Copyright 2004-2006 by Mathieu Bouchard
+  Copyright 2000-2001 IEM KUG Graz Austria (Thomas Musil)
+  Copyright (c) 1997-1999 Miller Puckette.
+  For information on usage and redistribution, and for a DISCLAIMER OF ALL
+  WARRANTIES, see the file, "LICENSE.txt", in this distribution.
+
+  this file declares the C interface for the second half of DesireData.
+  this is where most of the differences between DesireData and PureData lie.
+
+  SYNONYMS:
+    1. glist = graph = canvas = patcher; those were not always synonymous.
+       however, graph sometimes means a canvas that is displaying an array.
+    2. outconnect = connection = patchcord = wire
+
+  canvases have a few flags that determine their appearance:
+    gl_havewindow: should open its own window (only if mapped? or...)
+    gl_isgraph:    the GOP flag: show as graph-on-parent, vs TextBox.
+    gl_owner==0:   it's a root canvas, should be in canvas_list.
+                   In this case "gl_havewindow" is always set.
+
+  canvas_list is a list of root windows only, which can be traversed using canvases_each.
+
+  If a canvas has a window it may still not be "mapped."  Miniaturized
+  windows aren't mapped, for example, but a window is also not mapped
+  immediately upon creation.  In either case gl_havewindow is true but
+  gl_mapped is false.
+
+  Closing a non-root window makes it invisible; closing a root destroys it.
+  A canvas that's just a text object on its parent is always "toplevel."  An
+  embedded canvas can switch back and forth to appear as a toplevel by double-
+  clicking on it.  Single-clicking a text box makes the toplevel become visible
+  and raises the window it's in.
+
+  If a canvas shows up as a graph on its parent, the graph is blanked while the
+  canvas has its own window, even if miniaturized.
+*/
+
+#ifndef DESIRE
+#define DESIRE
+#endif
+#ifndef __DESIRE_H
+#define __DESIRE_H
+
+#include "m_pd.h"
+#include "s_stuff.h"
+
+#if defined(_LANGUAGE_C_PLUS_PLUS) || defined(__cplusplus)
+//#include <map>
+extern "C" {
+#endif
+
+/* ----------------------- m_imp.h ---------------------------------------------------*/
+
+typedef struct _methodentry {
+    t_symbol *me_name;
+    t_gotfn me_fun;
+    t_atomtype me_arg[MAXPDARG+1];
+} t_methodentry;
+
+typedef void (*t_bangmethod)   (t_pd *x);
+typedef void (*t_pointermethod)(t_pd *x, t_gpointer *gp);
+typedef void (*t_floatmethod)  (t_pd *x, t_float f);
+typedef void (*t_symbolmethod) (t_pd *x, t_symbol *s);
+typedef void (*t_stringmethod) (t_pd *x, const char *s);
+typedef void (*t_listmethod)   (t_pd *x, t_symbol *s, int argc, t_atom *argv);
+typedef void (*t_anymethod)    (t_pd *x, t_symbol *s, int argc, t_atom *argv);
+
+t_pd *pd_new2(int argc, t_atom *argv);
+t_pd *pd_new3(const char *s);
+
+struct _class {
+    t_symbol *name;                   /* name (mostly for error reporting) */
+    t_symbol *helpname;               /* name of help file */
+    t_symbol *externdir;              /* directory extern was loaded from */
+    size_t size;                      /* size of an instance */
+    t_methodentry *methods;           /* methods other than bang, etc below */
+    int nmethod;                      /* number of methods */
+    t_method        freemethod;       /* function to call before freeing */
+    t_bangmethod    bangmethod;       /* common methods */
+    t_pointermethod pointermethod;
+    t_floatmethod   floatmethod;
+    t_symbolmethod  symbolmethod; /* or t_stringmethod, but only C++ has anonymous unions, so... */
+    t_listmethod    listmethod;
+    t_anymethod     anymethod;
+    t_savefn savefn;           /* function to call when saving */
+    int floatsignalin;         /* onset to float for signal input */
+    unsigned gobj:1;           /* true if is a gobj */
+    unsigned patchable:1;      /* true if we have a t_object header */
+    unsigned firstin:1;        /* if patchable, true if draw first inlet */
+    unsigned drawcommand:1;    /* a drawing command for a template */
+    unsigned newatoms:1;         /* can handle refcounting of atoms (future use) */
+    unsigned use_stringmethod:1; /* the symbolmethod slot holds a stringmethod instead */
+    t_symbol *firsttip;
+    t_symbol **fields; /* names of fields aka attributes, and I don't mean the #V attributes. */
+    int nfields; /* ... and how many of them */
+    t_notice notice;             /* observer method */
+    t_onsubscribe onsubscribe; /* observable method */
+};
+
+//#define c_methods methods /* for Cyclone */
+//#define c_nmethod nmethod /* for Cyclone */
+//#define c_externdir externdir /* for PDDP */
+//#define c_name name /* for Cyclone,Creb,Pidip */
+//#define c_size size /* for Cyclone,Flext */
+//#define me_name name /* for Cyclone */
+//#define me_fun fun /* for Cyclone */
+//#define me_arg arg /* for Cyclone */
+
+/* m_obj.c */
+EXTERN int obj_noutlets(t_object *x);
+EXTERN int obj_ninlets(t_object *x);
+EXTERN t_outconnect *obj_starttraverseoutlet(t_object *x, t_outlet **op, int nout);
+EXTERN t_outconnect *obj_nexttraverseoutlet(t_outconnect *lastconnect, t_object **destp, t_inlet **inletp, int *whichp);
+EXTERN t_outconnect *obj_connect(t_object *source, int outno, t_object *sink, int inno);
+EXTERN void obj_disconnect(t_object *source, int outno, t_object *sink, int inno);
+EXTERN void outlet_setstacklim(void);
+EXTERN int obj_issignalinlet(t_object *x, int m);
+EXTERN int obj_issignaloutlet(t_object *x, int m);
+EXTERN int obj_nsiginlets(t_object *x);
+EXTERN int obj_nsigoutlets(t_object *x);
+EXTERN int obj_siginletindex(t_object *x, int m);
+EXTERN int obj_sigoutletindex(t_object *x, int m);
+
+/* misc */
+EXTERN void glob_evalfile(t_pd *ignore, t_symbol *name, t_symbol *dir);
+EXTERN void glob_initfromgui(void *dummy, t_symbol *s);
+EXTERN void glob_quit(void *dummy);
+
+/* ----------------------- g_canvas.h ------------------------------------------------*/
+
+/* i don't know whether this is currently used at all in DesireData. -- matju 2006.09 */
+#ifdef GARRAY_THREAD_LOCK
+#include <pthread.h> /* TB: for t_garray */
+#endif
+
+typedef struct t_gtemplate t_gtemplate;
+typedef struct _canvasenvironment t_canvasenvironment;
+typedef struct _slot t_slot;
+
+/* the t_tick structure describes where to draw x and y "ticks" for a canvas */
+typedef struct _tick {  /* where to put ticks on x or y axes */
+    float point;      /* one point to draw a big tick at */
+    float inc;        /* x or y increment per little tick */
+    int lperb;        /* little ticks per big; 0 if no ticks to draw */
+} t_tick;
+
+typedef struct t_boxes t_boxes;
+
+/* the t_canvas structure, which describes a list of elements that live on an area of a window.*/
+#ifdef PD_PLUSPLUS_FACE
+struct _glist : t_object {
+#else
+struct _glist {
+    t_object gl_obj;         /* header in case we're a [pd] or abstraction */
+#endif
+    int pixwidth, pixheight; /* width in pixels (on parent, if a graph) */
+    float x1,y1,x2,y2;       /* bounding rectangle in our own coordinates */
+    int screenx1, screeny1, screenx2, screeny2; /* screen coordinates when toplevel */
+    int xmargin, ymargin;    /* origin for GOP rectangle */
+    /* ticks and tick labels */
+    t_tick xtick; int nxlabels; t_symbol **xlabel; float xlabely;
+    t_tick ytick; int nylabels; t_symbol **ylabel; float ylabelx;
+    t_symbol *name;            /* symbol bound here */
+    int font;                  /* nominal font size in points, e.g., 10 */
+    t_canvasenvironment *env;  /* one of these per $0; env=0 for subpatches */
+    unsigned int havewindow:1; /* this indicates whether we publish to the manager */
+    unsigned int gop:1;
+    unsigned int goprect:1;    /* gop version >= 0.39 */
+    unsigned int hidetext:1;   /* hide object-name + args when doing graph on parent */
+    long next_o_index;         /* next object index. to be incremented on each use */
+    long next_w_index;         /* next wire   index. to be incremented on each use */
+    t_boxes *boxes;
+};
+
+/* LATER consider adding font size to this struct (see canvas_getfont()) */
+struct _canvasenvironment {
+    t_symbol *dir;   /* directory patch lives in */
+    int argc;        /* number of "$" arguments */
+    t_atom *argv;    /* array of "$" arguments */
+    long dollarzero; /* value of "$0" */
+    t_namelist *path;/* search path (0.40) */
+};
+
+/* a data structure to describe a field in a pure datum */
+#define DT_FLOAT 0
+#define DT_SYMBOL 1
+#define DT_CANVAS 2
+#define DT_ARRAY 3
+
+typedef struct t_dataslot {
+    int type;
+    t_symbol *name;
+    t_symbol *arraytemplate;     /* filled in for arrays only */
+} t_dataslot;
+
+#ifdef PD_PLUSPLUS_FACE
+typedef struct t_template : t_pd {
+#else
+typedef struct t_template {
+    t_pd t_pdobj;               /* header */
+#endif
+    t_gtemplate *list;  /* list of "struct"/gtemplate objects */
+    t_symbol *sym;            /* name */
+    int n;                    /* number of dataslots (fields) */
+    t_dataslot *vec;          /* array of dataslots */
+} t_template;
+
+/* this is not really a t_object, but it needs to be observable and have a refcount, so... */
+#ifdef PD_PLUSPLUS_FACE
+struct _array : t_object {
+#else
+struct _array {
+    t_gobj gl_obj;
+#endif
+    int n;            /* number of elements */
+    int elemsize;     /* size in bytes; LATER get this from template */
+    char *vec;        /* array of elements */
+    t_symbol *templatesym;    /* template for elements */
+    t_gpointer gp;    /* pointer to scalar or array element we're in */
+};
+
+#ifdef PD_PLUSPLUS_FACE
+struct _garray : t_gobj {
+#else
+struct _garray {
+    t_gobj x_gobj;
+#endif
+    t_scalar *scalar;     /* scalar "containing" the array */
+    t_canvas *canvas;     /* containing canvas */
+    t_symbol *name;       /* unexpanded name (possibly with leading '$') */
+    t_symbol *realname;   /* expanded name (symbol we're bound to) */
+    unsigned int usedindsp:1;   /* true if some DSP routine is using this */
+    unsigned int saveit:1;      /* true if we should save this with parent */
+    unsigned int listviewing:1; /* true if list view window is open */
+    unsigned int hidename:1;    /* don't print name above graph */
+};
+
+t_array *garray_getarray(t_garray *x);
+
+/* structure for traversing all the connections in a canvas */
+typedef struct t_linetraverser {
+    t_canvas *canvas;
+    t_object *from; int nout; int outlet; t_outlet *outletp;
+    t_object *to;   int nin;  int inlet;  t_inlet  *inletp;
+    t_outconnect *next;
+    int nextoutno;
+#ifdef __cplusplus
+    t_linetraverser() {}
+    t_linetraverser(t_canvas *canvas);
+#endif
+} t_linetraverser;
+
+extern t_canvas *canvas_list; /* list of all root canvases */
+extern t_class *vinlet_class, *voutlet_class, *canvas_class;
+extern int canvas_valid;         /* incremented when pointers might be stale */
+EXTERN int sys_noloadbang;
+EXTERN t_symbol *s_empty;
+
+#define PLOTSTYLE_POINTS 0     /* plotting styles for arrays */
+#define PLOTSTYLE_POLY 1
+#define PLOTSTYLE_BEZ 2
+
+/* from kernel.c */
+EXTERN void gobj_save(t_gobj *x, t_binbuf *b);
+EXTERN void pd_eval_text(char *t, size_t size);
+EXTERN int sys_syntax;
+
+/* from desire.c */
+EXTERN int pd_scanargs(int argc, t_atom *argv, char *fmt, ...);
+EXTERN int pd_saveargs(t_binbuf *b, char *fmt, ...);
+EXTERN void pd_upload(t_gobj *self);
+EXTERN void sys_mgui(void *self,   const char *sel, const char *fmt, ...);
+EXTERN void canvas_add(t_canvas *x, t_gobj *g, int index=-1);
+EXTERN void canvas_delete(t_canvas *x, t_gobj *y);
+EXTERN void canvas_deletelinesfor(t_canvas *x, t_text *text);
+EXTERN void canvas_deletelinesforio(t_canvas *x, t_text *text, t_inlet *inp, t_outlet *outp);
+EXTERN int canvas_isvisible(t_canvas *x);
+EXTERN int canvas_istoplevel(t_canvas *x);
+EXTERN int canvas_istable(t_canvas *x);
+EXTERN int canvas_isabstraction(t_canvas *x);
+EXTERN t_canvas *canvas_getcanvas(t_canvas *x);
+EXTERN t_canvas *canvas_getrootfor(t_canvas *x);
+EXTERN t_canvas *canvas_getcurrent(void);
+EXTERN t_canvasenvironment *canvas_getenv(t_canvas *x);
+EXTERN int canvas_getdollarzero(void);
+EXTERN t_symbol *canvas_realizedollar(t_canvas *x, t_symbol *s);
+EXTERN t_symbol *canvas_makebindsym(t_symbol *s);
+
+EXTERN void linetraverser_start(t_linetraverser *t, t_canvas *x);
+EXTERN t_outconnect *linetraverser_next(t_linetraverser *t);
+
+/* -------------------- TO BE SORTED OUT --------------------- */
+EXTERN void canvas_redrawallfortemplatecanvas(t_canvas *x, int action);
+EXTERN void array_resize(t_array *x, int n);
+EXTERN void word_init(t_word *wp, t_template *tmpl, t_gpointer *gp);
+EXTERN void word_restore(t_word *wp, t_template *tmpl, int argc, t_atom *argv);
+EXTERN t_scalar *scalar_new(t_canvas *owner, t_symbol *templatesym);
+EXTERN void word_free(t_word *wp, t_template *tmpl);
+EXTERN void scalar_redraw(t_scalar *x, t_canvas *canvas);
+//EXTERN int pd_pickle(t_foo *foo, char *fmt, ...);
+EXTERN void pd_set_newest (t_pd *x);
+char* inlet_tip(t_inlet* i,int num);
+
+extern t_hash<t_pd *,long> *object_table;
+extern t_hash<t_symbol *,t_class *> *class_table;
+
+/* some kernel.c stuff that wasn't in any header, when shifting to C++. */
+void obj_moveinletfirst(t_object *x, t_inlet *i);
+void obj_moveoutletfirst(t_object *x, t_outlet *o);
+int inlet_getsignalindex(t_inlet *x);
+int outlet_getsignalindex(t_outlet *x);
+void text_save(t_gobj *z, t_binbuf *b);
+t_sample *obj_findsignalscalar(t_object *x, int m);
+void class_set_extern_dir(t_symbol *s);
+void glob_update_class_info (t_pd *bogus, t_symbol *s, t_symbol *cb_recv, t_symbol *cb_sel);
+void pd_free_zombie(t_pd *x);
+
+/* some other stuff that wasn't in any header */
+void glob_watchdog(t_pd *dummy);
+
+#if defined(_LANGUAGE_C_PLUS_PLUS) || defined(__cplusplus)
+}
+#endif
+
+#ifdef __cplusplus
+#include<iostream>
+template <class T> static T min(T a, T b) {return a<b?a:b;}
+template <class T> static T max(T a, T b) {return a>b?a:b;}
+template <class T> T clip(T a, T b, T c) {return min(max(a,b),c);}
+void  oprintf(std::ostream &buf, const char *s, ...);
+void voprintf(std::ostream &buf, const char *s, va_list args);
+EXTERN std::ostringstream lost_posts;
+#endif
+
+#define L post("%s:%d in %s",__FILE__,__LINE__,__PRETTY_FUNCTION__);
+#define LS(self) post("%s:%d in %s (self=%lx class=%s)",__FILE__,__LINE__,__PRETTY_FUNCTION__,(long)self, \
+	((t_gobj *)self)->_class->name->name);
+
+#define STACKSIZE 1024
+struct t_call {
+	t_pd *self;  /* receiver */
+	t_symbol *s; /* selector */
+	/* insert temporary profiling variables here */
+};
+
+EXTERN t_call pd_stack[STACKSIZE];
+EXTERN int pd_stackn;
+
+EXTERN int gstack_empty(); /* that's a completely different stack: see pd_pushsym,pd_popsym */
+
+#endif /* __DESIRE_H */