aboutsummaryrefslogtreecommitdiff
path: root/pd/src/g_text.c
diff options
context:
space:
mode:
Diffstat (limited to 'pd/src/g_text.c')
-rw-r--r--pd/src/g_text.c1070
1 files changed, 1070 insertions, 0 deletions
diff --git a/pd/src/g_text.c b/pd/src/g_text.c
new file mode 100644
index 00000000..226ddc7a
--- /dev/null
+++ b/pd/src/g_text.c
@@ -0,0 +1,1070 @@
+/* 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. */
+
+/* changes by Thomas Musil IEM KUG Graz Austria 2001 */
+/* the methods for calling the gui-objects from menu are implemented */
+/* all changes are labeled with iemlib */
+
+#include <stdlib.h>
+#include "m_imp.h"
+#include "t_tk.h"
+#include "g_canvas.h"
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+static t_class *text_class;
+static t_class *message_class;
+static t_class *gatom_class;
+void canvas_startmotion(t_canvas *x);
+t_widgetbehavior text_widgetbehavior;
+
+/* ----------------- the "text" object. ------------------ */
+
+
+ /* add a "text" object (comment) to a glist. While this one goes for any glist,
+ the other 3 below are for canvases only. (why?) This is called
+ without args if invoked from the GUI; otherwise at least x and y
+ are provided. */
+
+void glist_text(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ t_text *x = (t_text *)pd_new(text_class);
+ t_atom at;
+ x->te_width = 0; /* don't know it yet. */
+ x->te_type = T_TEXT;
+ x->te_binbuf = binbuf_new();
+ if (argc > 1)
+ {
+ x->te_xpix = atom_getfloatarg(0, argc, argv);
+ x->te_ypix = atom_getfloatarg(1, argc, argv);
+ if (argc > 2) binbuf_restore(x->te_binbuf, argc-2, argv+2);
+ else
+ {
+ SETSYMBOL(&at, gensym("comment"));
+ binbuf_restore(x->te_binbuf, 1, &at);
+ }
+ glist_add(gl, &x->te_g);
+ }
+ else
+ {
+ int xpix, ypix;
+ pd_vmess((t_pd *)glist_getcanvas(gl), gensym("editmode"), "i", 1);
+ SETSYMBOL(&at, gensym("comment"));
+ glist_noselect(gl);
+ glist_getnextxy(gl, &xpix, &ypix);
+ x->te_xpix = glist_pixelstox(gl, xpix-3);
+ x->te_ypix = glist_pixelstoy(gl, ypix-3);
+ binbuf_restore(x->te_binbuf, 1, &at);
+ glist_add(gl, &x->te_g);
+ glist_noselect(gl);
+ glist_select(gl, &x->te_g);
+ canvas_startmotion(glist_getcanvas(gl));
+ }
+}
+
+/* ----------------- the "object" object. ------------------ */
+
+extern t_pd *newest;
+void canvas_getargs(int *argcp, t_atom **argvp);
+
+static void canvas_objtext(t_glist *gl, int xpix, int ypix, int selected,
+ t_binbuf *b)
+{
+ t_text *x;
+ int argc;
+ t_atom *argv;
+ newest = 0;
+ canvas_setcurrent((t_canvas *)gl);
+ canvas_getargs(&argc, &argv);
+ binbuf_eval(b, &pd_objectmaker, argc, argv);
+ if (binbuf_getnatom(b))
+ {
+ if (!newest)
+ {
+ binbuf_print(b);
+ post("... couldn't create");
+ x = 0;
+ }
+ else if (!(x = pd_checkobject(newest)))
+ {
+ binbuf_print(b);
+ post("... didn't return a patchable object");
+ }
+ }
+ else x = 0;
+ if (!x)
+ {
+
+ /* LATER make the color reflect this */
+ x = (t_text *)pd_new(text_class);
+ }
+ x->te_binbuf = b;
+ x->te_xpix = xpix;
+ x->te_ypix = ypix;
+ x->te_width = 0;
+ x->te_type = T_OBJECT;
+ glist_add(gl, &x->te_g);
+ if (selected)
+ {
+ /* this is called if we've been created from the menu. */
+ glist_select(gl, &x->te_g);
+ gobj_activate(&x->te_g, gl, 1);
+ }
+ if (pd_class(&x->ob_pd) == vinlet_class)
+ canvas_resortinlets(glist_getcanvas(gl));
+ if (pd_class(&x->ob_pd) == voutlet_class)
+ canvas_resortoutlets(glist_getcanvas(gl));
+ canvas_unsetcurrent((t_canvas *)gl);
+}
+
+ /* object creation routine. These are called without any arguments if
+ they're invoked from the
+ gui; when pasting or restoring from a file, we get at least x and y. */
+
+void canvas_obj(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ t_text *x;
+ if (argc >= 2)
+ {
+ t_binbuf *b = binbuf_new();
+ binbuf_restore(b, argc-2, argv+2);
+ canvas_objtext(gl, atom_getintarg(0, argc, argv),
+ atom_getintarg(1, argc, argv), 0, b);
+ }
+ else
+ {
+ t_binbuf *b = binbuf_new();
+ int xpix, ypix;
+ pd_vmess(&gl->gl_pd, gensym("editmode"), "i", 1);
+ glist_noselect(gl);
+ glist_getnextxy(gl, &xpix, &ypix);
+ canvas_objtext(gl, xpix, ypix, 1, b);
+ canvas_startmotion(glist_getcanvas(gl));
+ }
+}
+
+/* make an object box for an object that's already there. */
+
+/* iemlib */
+void canvas_iemguis(t_glist *gl, t_symbol *guiobjname)
+{
+ t_atom at;
+ t_binbuf *b = binbuf_new();
+ int xpix, ypix;
+
+ pd_vmess(&gl->gl_pd, gensym("editmode"), "i", 1);
+ glist_noselect(gl);
+ SETSYMBOL(&at, guiobjname);
+ binbuf_restore(b, 1, &at);
+ glist_getnextxy(gl, &xpix, &ypix);
+ canvas_objtext(gl, xpix, ypix, 1, b);
+ canvas_startmotion(glist_getcanvas(gl));
+}
+
+void canvas_bng(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ canvas_iemguis(gl, gensym("bng"));
+}
+
+void canvas_toggle(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ canvas_iemguis(gl, gensym("tgl"));
+}
+
+void canvas_vslider(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ canvas_iemguis(gl, gensym("vsl"));
+}
+
+void canvas_hslider(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ canvas_iemguis(gl, gensym("hsl"));
+}
+
+void canvas_hdial(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ canvas_iemguis(gl, gensym("hdl"));
+}
+
+void canvas_vdial(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ canvas_iemguis(gl, gensym("vdl"));
+}
+
+void canvas_vumeter(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ canvas_iemguis(gl, gensym("vu"));
+}
+
+void canvas_mycnv(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ canvas_iemguis(gl, gensym("cnv"));
+}
+
+void canvas_numbox(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ canvas_iemguis(gl, gensym("nbx"));
+}
+
+/* iemlib */
+
+void canvas_objfor(t_glist *gl, t_text *x, int argc, t_atom *argv)
+{
+ x->te_width = 0; /* don't know it yet. */
+ x->te_type = T_OBJECT;
+ x->te_binbuf = binbuf_new();
+ x->te_xpix = atom_getfloatarg(0, argc, argv);
+ x->te_ypix = atom_getfloatarg(1, argc, argv);
+ if (argc > 2) binbuf_restore(x->te_binbuf, argc-2, argv+2);
+ glist_add(gl, &x->te_g);
+}
+
+/* ---------------------- the "message" text item ------------------------ */
+
+typedef struct _messresponder
+{
+ t_pd mr_pd;
+ t_outlet *mr_outlet;
+} t_messresponder;
+
+typedef struct _message
+{
+ t_text m_text;
+ t_messresponder m_messresponder;
+ t_glist *m_glist;
+ t_clock *m_clock;
+} t_message;
+
+static t_class *message_class, *messresponder_class;
+
+static void messresponder_bang(t_messresponder *x)
+{
+ outlet_bang(x->mr_outlet);
+}
+
+static void messresponder_float(t_messresponder *x, t_float f)
+{
+ outlet_float(x->mr_outlet, f);
+}
+
+static void messresponder_symbol(t_messresponder *x, t_symbol *s)
+{
+ outlet_symbol(x->mr_outlet, s);
+}
+
+static void messresponder_list(t_messresponder *x,
+ t_symbol *s, int argc, t_atom *argv)
+{
+ outlet_list(x->mr_outlet, s, argc, argv);
+}
+
+static void messresponder_anything(t_messresponder *x,
+ t_symbol *s, int argc, t_atom *argv)
+{
+ outlet_anything(x->mr_outlet, s, argc, argv);
+}
+
+static void message_bang(t_message *x)
+{
+ binbuf_eval(x->m_text.te_binbuf, &x->m_messresponder.mr_pd, 0, 0);
+}
+
+static void message_float(t_message *x, t_float f)
+{
+ t_atom at;
+ SETFLOAT(&at, f);
+ binbuf_eval(x->m_text.te_binbuf, &x->m_messresponder.mr_pd, 1, &at);
+}
+
+static void message_symbol(t_message *x, t_symbol *s)
+{
+ t_atom at;
+ SETSYMBOL(&at, s);
+ binbuf_eval(x->m_text.te_binbuf, &x->m_messresponder.mr_pd, 1, &at);
+}
+
+static void message_list(t_message *x, t_symbol *s, int argc, t_atom *argv)
+{
+ binbuf_eval(x->m_text.te_binbuf, &x->m_messresponder.mr_pd, argc, argv);
+}
+
+static void message_set(t_message *x, t_symbol *s, int argc, t_atom *argv)
+{
+ binbuf_clear(x->m_text.te_binbuf);
+ binbuf_add(x->m_text.te_binbuf, argc, argv);
+ glist_retext(x->m_glist, &x->m_text);
+}
+
+static void message_add2(t_message *x, t_symbol *s, int argc, t_atom *argv)
+{
+ binbuf_add(x->m_text.te_binbuf, argc, argv);
+ glist_retext(x->m_glist, &x->m_text);
+}
+
+static void message_add(t_message *x, t_symbol *s, int argc, t_atom *argv)
+{
+ binbuf_add(x->m_text.te_binbuf, argc, argv);
+ binbuf_addsemi(x->m_text.te_binbuf);
+ glist_retext(x->m_glist, &x->m_text);
+}
+
+static void message_click(t_message *x,
+ t_floatarg xpos, t_floatarg ypos, t_floatarg shift,
+ t_floatarg ctrl, t_floatarg alt)
+{
+ message_float(x, 0);
+ if (glist_isvisible(x->m_glist))
+ {
+ t_rtext *y = glist_findrtext(x->m_glist, &x->m_text);
+ sys_vgui(".x%x.c itemconfigure %sR -width 5\n",
+ glist_getcanvas(x->m_glist), rtext_gettag(y));
+ clock_delay(x->m_clock, 120);
+ }
+}
+
+static void message_tick(t_message *x)
+{
+ if (glist_isvisible(x->m_glist))
+ {
+ t_rtext *y = glist_findrtext(x->m_glist, &x->m_text);
+ sys_vgui(".x%x.c itemconfigure %sR -width 1\n",
+ glist_getcanvas(x->m_glist), rtext_gettag(y));
+ }
+}
+
+static void message_free(t_message *x)
+{
+ clock_free(x->m_clock);
+}
+
+void canvas_msg(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ t_message *x = (t_message *)pd_new(message_class);
+ x->m_messresponder.mr_pd = messresponder_class;
+ x->m_messresponder.mr_outlet = outlet_new(&x->m_text, &s_float);
+ x->m_text.te_width = 0; /* don't know it yet. */
+ x->m_text.te_type = T_MESSAGE;
+ x->m_text.te_binbuf = binbuf_new();
+ x->m_glist = gl;
+ x->m_clock = clock_new(x, (t_method)message_tick);
+ if (argc > 1)
+ {
+ x->m_text.te_xpix = atom_getfloatarg(0, argc, argv);
+ x->m_text.te_ypix = atom_getfloatarg(1, argc, argv);
+ if (argc > 2) binbuf_restore(x->m_text.te_binbuf, argc-2, argv+2);
+ glist_add(gl, &x->m_text.te_g);
+ }
+ else
+ {
+ int xpix, ypix;
+ pd_vmess(&gl->gl_pd, gensym("editmode"), "i", 1);
+ glist_noselect(gl);
+ glist_getnextxy(gl, &xpix, &ypix);
+ x->m_text.te_xpix = xpix-3;
+ x->m_text.te_ypix = ypix-3;
+ glist_add(gl, &x->m_text.te_g);
+ glist_noselect(gl);
+ glist_select(gl, &x->m_text.te_g);
+ canvas_startmotion(glist_getcanvas(gl));
+ }
+}
+
+/* ---------------------- the "atom" text item ------------------------ */
+
+#define ATOMBUFSIZE 40
+
+typedef struct _gatom
+{
+ t_text a_text;
+ t_atom a_atom; /* this holds the value and the type */
+ t_glist *a_glist; /* owning glist */
+ t_float a_toggle; /* value to toggle to */
+ t_float a_draghi; /* high end of drag range */
+ t_float a_draglo; /* low end of drag range */
+ char a_buf[ATOMBUFSIZE];
+ char a_shift;
+} t_gatom;
+
+static void gatom_set(t_gatom *x, t_symbol *s, int argc, t_atom *argv)
+{
+ if (!argc) return;
+ if (x->a_atom.a_type == A_FLOAT)
+ x->a_atom.a_w.w_float = atom_getfloat(argv);
+ else if (x->a_atom.a_type == A_SYMBOL)
+ x->a_atom.a_w.w_symbol = atom_getsymbol(argv);
+ binbuf_clear(x->a_text.te_binbuf);
+ binbuf_add(x->a_text.te_binbuf, 1, &x->a_atom);
+ glist_retext(x->a_glist, &x->a_text);
+ x->a_buf[0] = 0;
+}
+
+static void gatom_bang(t_gatom *x)
+{
+ if (x->a_atom.a_type == A_FLOAT)
+ outlet_float(x->a_text.te_outlet, x->a_atom.a_w.w_float);
+ else if (x->a_atom.a_type == A_SYMBOL)
+ outlet_symbol(x->a_text.te_outlet, x->a_atom.a_w.w_symbol);
+}
+
+static void gatom_float(t_gatom *x, t_float f)
+{
+ t_atom at;
+ SETFLOAT(&at, f);
+ gatom_set(x, 0, 1, &at);
+ gatom_bang(x);
+}
+
+static void gatom_clipfloat(t_gatom *x, t_float f)
+{
+ if (x->a_draglo != 0 || x->a_draghi != 0)
+ {
+ if (f < x->a_draglo)
+ f = x->a_draglo;
+ if (f > x->a_draghi)
+ f = x->a_draghi;
+ }
+ gatom_float(x, f);
+}
+
+static void gatom_symbol(t_gatom *x, t_symbol *s)
+{
+ t_atom at;
+ SETSYMBOL(&at, s);
+ gatom_set(x, 0, 1, &at);
+ gatom_bang(x);
+}
+
+static void gatom_motion(void *z, t_floatarg dx, t_floatarg dy)
+{
+ t_gatom *x = (t_gatom *)z;
+ if (dy == 0) return;
+ if (x->a_atom.a_type == A_FLOAT)
+ {
+ if (x->a_shift)
+ {
+ double nval = x->a_atom.a_w.w_float - 0.01 * dy;
+ double trunc = 0.01 * (floor(100. * nval + 0.5));
+ if (trunc < nval + 0.0001 && trunc > nval - 0.0001) nval = trunc;
+ gatom_clipfloat(x, nval);
+ }
+ else
+ {
+ double nval = x->a_atom.a_w.w_float - dy;
+ double trunc = 0.01 * (floor(100. * nval + 0.5));
+ if (trunc < nval + 0.0001 && trunc > nval - 0.0001) nval = trunc;
+ trunc = floor(nval + 0.5);
+ if (trunc < nval + 0.001 && trunc > nval - 0.001) nval = trunc;
+ gatom_clipfloat(x, nval);
+ }
+ }
+}
+
+static void gatom_key(void *z, t_floatarg f)
+{
+ t_gatom *x = (t_gatom *)z;
+ int c = f;
+ int l = strlen(x->a_buf);
+ t_atom at;
+ char sbuf[ATOMBUFSIZE + 4];
+ if (c == ' ') return;
+ else if (c == '\b')
+ {
+ if (l > 0)
+ {
+ x->a_buf[l-1] = 0;
+ goto redraw;
+ }
+ }
+ else if (c == '\n')
+ {
+ if (x->a_atom.a_type == A_FLOAT)
+ gatom_float(x, atof(x->a_buf));
+ else if (x->a_atom.a_type == A_SYMBOL)
+ gatom_symbol(x, gensym(x->a_buf));
+ else bug("gatom_key");
+ }
+ else if (l < (ATOMBUFSIZE-1))
+ {
+ x->a_buf[l] = c;
+ x->a_buf[l+1] = 0;
+ goto redraw;
+ }
+ return;
+redraw:
+ /* LATER figure out how to avoid creating all these symbols! */
+ sprintf(sbuf, "%s...", x->a_buf);
+ SETSYMBOL(&at, gensym(sbuf));
+ binbuf_clear(x->a_text.te_binbuf);
+ binbuf_add(x->a_text.te_binbuf, 1, &at);
+ glist_retext(x->a_glist, &x->a_text);
+}
+
+static void gatom_click(t_gatom *x,
+ t_floatarg xpos, t_floatarg ypos, t_floatarg shift, t_floatarg ctrl,
+ t_floatarg alt)
+{
+ if (x->a_text.te_width == 1)
+ {
+ if (x->a_atom.a_type == A_FLOAT)
+ gatom_float(x, (x->a_atom.a_w.w_float == 0));
+ }
+ else
+ {
+ if (alt)
+ {
+ if (x->a_atom.a_type != A_FLOAT) return;
+ if (x->a_atom.a_w.w_float != 0)
+ {
+ x->a_toggle = x->a_atom.a_w.w_float;
+ gatom_float(x, 0);
+ return;
+ }
+ else gatom_float(x, x->a_toggle);
+ }
+ x->a_shift = shift;
+ x->a_buf[0] = 0;
+ glist_grab(x->a_glist, &x->a_text.te_g, gatom_motion, gatom_key,
+ xpos, ypos);
+ }
+}
+
+static void gatom_param(t_gatom *x, t_floatarg width, t_floatarg draglo,
+ t_floatarg draghi)
+{
+ if (draglo >= draghi)
+ draglo = draghi = 0;
+ x->a_draglo = draglo;
+ x->a_draghi = draghi;
+ if (width < 0)
+ width = 4;
+ else if (width > 80)
+ width = 80;
+ x->a_text.te_width = width;
+ glist_retext(x->a_glist, &x->a_text);
+}
+
+void canvas_atom(t_glist *gl, t_atomtype type,
+ t_symbol *s, int argc, t_atom *argv)
+{
+ t_gatom *x = (t_gatom *)pd_new(gatom_class);
+ t_atom at;
+ x->a_text.te_width = 0; /* don't know it yet. */
+ x->a_text.te_type = T_ATOM;
+ x->a_text.te_binbuf = binbuf_new();
+ x->a_glist = gl;
+ x->a_atom.a_type = type;
+ x->a_toggle = 1;
+ x->a_draglo = 0;
+ x->a_draghi = 0;
+ if (type == A_FLOAT)
+ {
+ x->a_atom.a_w.w_float = 0;
+ x->a_text.te_width = 5;
+ outlet_new(&x->a_text, &s_float);
+ SETFLOAT(&at, 0);
+ }
+ else
+ {
+ x->a_atom.a_w.w_symbol = &s_symbol;
+ x->a_text.te_width = 10;
+ outlet_new(&x->a_text, &s_symbol);
+ SETSYMBOL(&at, &s_symbol);
+ }
+ binbuf_add(x->a_text.te_binbuf, 1, &at);
+ if (argc > 1)
+ {
+ x->a_text.te_xpix = atom_getfloatarg(0, argc, argv);
+ x->a_text.te_ypix = atom_getfloatarg(1, argc, argv);
+ x->a_text.te_width = atom_getintarg(2, argc, argv);
+ /* sanity check because some very old patches have trash in this
+ field... remove this in 2003 or so: */
+ if (x->a_text.te_width < 0 || x->a_text.te_width > 500)
+ x->a_text.te_width = 4;
+ x->a_draglo = atom_getfloatarg(3, argc, argv);
+ x->a_draghi = atom_getfloatarg(4, argc, argv);
+ glist_add(gl, &x->a_text.te_g);
+ }
+ else
+ {
+ int xpix, ypix;
+ pd_vmess(&gl->gl_pd, gensym("editmode"), "i", 1);
+ glist_noselect(gl);
+ glist_getnextxy(gl, &xpix, &ypix);
+ x->a_text.te_xpix = xpix;
+ x->a_text.te_ypix = ypix;
+ glist_add(gl, &x->a_text.te_g);
+ glist_noselect(gl);
+ glist_select(gl, &x->a_text.te_g);
+ canvas_startmotion(glist_getcanvas(gl));
+ }
+}
+
+void canvas_floatatom(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ canvas_atom(gl, A_FLOAT, s, argc, argv);
+}
+
+void canvas_symbolatom(t_glist *gl, t_symbol *s, int argc, t_atom *argv)
+{
+ canvas_atom(gl, A_SYMBOL, s, argc, argv);
+}
+
+static void gatom_free(t_gatom *x)
+{
+ gfxstub_deleteforkey(x);
+}
+
+static void gatom_properties(t_gobj *z, t_glist *owner)
+{
+ t_gatom *x = (t_gatom *)z;
+ char buf[200];
+ sprintf(buf, "pdtk_gatom_dialog %%s %d %g %g\n",
+ x->a_text.te_width, x->a_draglo, x->a_draghi);
+ gfxstub_new(&x->a_text.te_pd, x, buf);
+}
+
+
+/* -------------------- widget behavior for text objects ------------ */
+
+static void text_getrect(t_gobj *z, t_glist *glist,
+ int *xp1, int *yp1, int *xp2, int *yp2)
+{
+ t_text *x = (t_text *)z;
+ int width, height, iscomment = (x->te_type == T_TEXT);
+ float x1, y1, x2, y2;
+
+ /* for number boxes, we know width and height a priori, and should
+ report them here so that graphs can get swelled to fit. */
+
+ if (x->te_type == T_ATOM && x->te_width > 0)
+ {
+ int font = glist_getfont(glist);
+ int fontwidth = sys_fontwidth(font), fontheight = sys_fontheight(font);
+ width = (x->te_width > 0 ? x->te_width : 6) * fontwidth + 2;
+ height = fontheight + 1; /* borrowed from TMARGIN, etc, in g_rtext.c */
+ }
+ /* if we're invisible we don't know our size so we just lie about
+ it. This is called on invisible boxes to establish order of inlets
+ and possibly other reasons.
+ To find out if the box is visible we can't just check the "vis"
+ flag because we might be within the vis() routine and not have set
+ that yet. So we check directly whether the "rtext" list has been
+ built. LATER reconsider when "vis" flag should be on and off? */
+
+ else if (glist->gl_editor && glist->gl_editor->e_rtext)
+ {
+ t_rtext *y = glist_findrtext(glist, x);
+ width = rtext_width(y);
+ height = rtext_height(y) - (iscomment << 1);
+ }
+ else width = height = 10;
+ x1 = text_xpix(x, glist);
+ y1 = text_ypix(x, glist);
+ x2 = x1 + width;
+ y2 = y1 + height;
+ y1 += iscomment;
+ *xp1 = x1;
+ *yp1 = y1;
+ *xp2 = x2;
+ *yp2 = y2;
+}
+
+static void text_displace(t_gobj *z, t_glist *glist,
+ int dx, int dy)
+{
+ t_text *x = (t_text *)z;
+ x->te_xpix += dx;
+ x->te_ypix += dy;
+ if (glist_isvisible(glist))
+ {
+ t_rtext *y = glist_findrtext(glist, x);
+ rtext_displace(y, dx, dy);
+ text_drawborder(x, glist, rtext_gettag(y),
+ rtext_width(y), rtext_height(y), 0);
+ canvas_fixlinesfor(glist_getcanvas(glist), x);
+ }
+}
+
+static void text_select(t_gobj *z, t_glist *glist, int state)
+{
+ t_text *x = (t_text *)z;
+ t_rtext *y = glist_findrtext(glist, x);
+ rtext_select(y, state);
+ sys_vgui(".x%x.c itemconfigure %sR -fill %s\n", glist,
+ rtext_gettag(y), (state? "blue" : "black"));
+}
+
+static void text_activate(t_gobj *z, t_glist *glist, int state)
+{
+ t_text *x = (t_text *)z;
+ t_rtext *y = glist_findrtext(glist, x);
+ if (z->g_pd != gatom_class) rtext_activate(y, state);
+}
+
+static void text_delete(t_gobj *z, t_glist *glist)
+{
+ t_text *x = (t_text *)z;
+ canvas_deletelinesfor(glist, x);
+}
+
+ /* return true if the text box should be drawn.
+ We don't show object boxes inside graphs. */
+int text_shouldvis(t_text *x, t_glist *glist)
+{
+ return (glist->gl_havewindow ||
+ (x->te_pd != canvas_class && x->te_pd->c_wb != &text_widgetbehavior) ||
+ (x->te_pd == canvas_class && (((t_glist *)x)->gl_isgraph)));
+}
+
+static void text_vis(t_gobj *z, t_glist *glist, int vis)
+{
+ t_text *x = (t_text *)z;
+ if (vis)
+ {
+ if (text_shouldvis(x, glist))
+ {
+ t_rtext *y = rtext_new(glist, x, glist->gl_editor->e_rtext, 1);
+ if (x->te_type == T_ATOM)
+ glist_retext(glist, x);
+ text_drawborder(x, glist, rtext_gettag(y),
+ rtext_width(y), rtext_height(y), 1);
+ }
+ else rtext_new(glist, x, glist->gl_editor->e_rtext, 0);
+ }
+ else
+ {
+ t_rtext *y = glist_findrtext(glist, x);
+ if (text_shouldvis(x, glist))
+ text_eraseborder(x, glist, rtext_gettag(y));
+ rtext_free(y);
+ }
+}
+
+static int text_click(t_gobj *z, struct _glist *glist,
+ int xpix, int ypix, int shift, int alt, int dbl, int doit)
+{
+ t_text *x = (t_text *)z;
+ if (x->te_type == T_OBJECT)
+ {
+ t_symbol *clicksym = gensym("click");
+ if (zgetfn(&x->te_pd, clicksym))
+ {
+ if (doit)
+ pd_vmess(&x->te_pd, clicksym, "fffff",
+ (double)xpix, (double)ypix,
+ (double)shift, 0, (double)alt);
+ return (1);
+ }
+ else return (0);
+ }
+ else if (x->te_type == T_ATOM)
+ {
+ if (doit)
+ gatom_click((t_gatom *)x, (t_floatarg)xpix, (t_floatarg)ypix,
+ (t_floatarg)shift, 0, (t_floatarg)alt);
+ return (1);
+ }
+ else if (x->te_type == T_MESSAGE)
+ {
+ if (doit)
+ message_click((t_message *)x, (t_floatarg)xpix, (t_floatarg)ypix,
+ (t_floatarg)shift, 0, (t_floatarg)alt);
+ return (1);
+ }
+ else return (0);
+}
+
+static void text_save(t_gobj *z, t_binbuf *b)
+{
+ t_text *x = (t_text *)z;
+ if (x->te_type == T_OBJECT)
+ {
+ /* if we have a "saveto" method, and if we don't happen to be
+ a canvas that's an abstraction, the saveto method does the work */
+ if (zgetfn(&x->te_pd, gensym("saveto")) &&
+ !((pd_class(&x->te_pd) == canvas_class) &&
+ (canvas_isabstraction((t_canvas *)x)
+ || canvas_istable((t_canvas *)x))))
+ {
+ mess1(&x->te_pd, gensym("saveto"), b);
+ binbuf_addv(b, "ssii", gensym("#X"), gensym("restore"),
+ (t_int)x->te_xpix, (t_int)x->te_ypix);
+ }
+ else /* otherwise just save the text */
+ {
+ binbuf_addv(b, "ssii", gensym("#X"), gensym("obj"),
+ (t_int)x->te_xpix, (t_int)x->te_ypix);
+ }
+ binbuf_addbinbuf(b, x->te_binbuf);
+ binbuf_addv(b, ";");
+ }
+ else if (x->te_type == T_MESSAGE)
+ {
+ binbuf_addv(b, "ssii", gensym("#X"), gensym("msg"),
+ (t_int)x->te_xpix, (t_int)x->te_ypix);
+ binbuf_addbinbuf(b, x->te_binbuf);
+ binbuf_addv(b, ";");
+ }
+ else if (x->te_type == T_ATOM)
+ {
+ t_atomtype t = ((t_gatom *)x)->a_atom.a_type;
+ t_symbol *sel = (t == A_SYMBOL ? gensym("symbolatom") :
+ (t == A_FLOAT ? gensym("floatatom") : gensym("intatom")));
+ binbuf_addv(b, "ssiiiff", gensym("#X"), sel,
+ (t_int)x->te_xpix, (t_int)x->te_ypix, (t_int)x->te_width,
+ (double)((t_gatom *)x)->a_draglo, (double)((t_gatom *)x)->a_draghi);
+ binbuf_addv(b, ";");
+ }
+ else
+ {
+ binbuf_addv(b, "ssii", gensym("#X"), gensym("text"),
+ (t_int)x->te_xpix, (t_int)x->te_ypix);
+ binbuf_addbinbuf(b, x->te_binbuf);
+ binbuf_addv(b, ";");
+ }
+}
+
+ /* this one is for everyone but "gatoms"; it's imposed in m_class.c */
+t_widgetbehavior text_widgetbehavior =
+{
+ text_getrect,
+ text_displace,
+ text_select,
+ text_activate,
+ text_delete,
+ text_vis,
+ text_click,
+ text_save,
+ 0,
+};
+
+static t_widgetbehavior gatom_widgetbehavior =
+{
+ text_getrect,
+ text_displace,
+ text_select,
+ text_activate,
+ text_delete,
+ text_vis,
+ text_click,
+ text_save,
+ gatom_properties,
+};
+
+/* -------------------- the "text" class ------------ */
+
+#ifdef MACOSX
+#define EXTRAPIX 2
+#else
+#define EXTRAPIX 1
+#endif
+
+ /* draw inlets and outlets for a text object or for a graph. */
+void glist_drawiofor(t_glist *glist, t_object *ob, int firsttime,
+ char *tag, int x1, int y1, int x2, int y2)
+{
+ int n = obj_noutlets(ob), nplus = (n == 1 ? 1 : n-1), i;
+ int width = x2 - x1;
+ for (i = 0; i < n; i++)
+ {
+ int onset = x1 + (width - IOWIDTH) * i / nplus;
+ if (firsttime)
+ sys_vgui(".x%x.c create rectangle %d %d %d %d -tags %so%d\n",
+ glist_getcanvas(glist),
+ onset, y2 - 1,
+ onset + IOWIDTH, y2,
+ tag, i);
+ else
+ sys_vgui(".x%x.c coords %so%d %d %d %d %d\n",
+ glist_getcanvas(glist), tag, i,
+ onset, y2 - 1,
+ onset + IOWIDTH, y2);
+ }
+ n = obj_ninlets(ob);
+ nplus = (n == 1 ? 1 : n-1);
+ for (i = 0; i < n; i++)
+ {
+ int onset = x1 + (width - IOWIDTH) * i / nplus;
+ if (firsttime)
+ sys_vgui(".x%x.c create rectangle %d %d %d %d -tags %si%d\n",
+ glist_getcanvas(glist),
+ onset, y1,
+ onset + IOWIDTH, y1 + EXTRAPIX,
+ tag, i);
+ else
+ sys_vgui(".x%x.c coords %si%d %d %d %d %d\n",
+ glist_getcanvas(glist), tag, i,
+ onset, y1,
+ onset + IOWIDTH, y1 + EXTRAPIX);
+ }
+}
+
+void text_drawborder(t_text *x, t_glist *glist,
+ char *tag, int width2, int height2, int firsttime)
+{
+ t_object *ob;
+ int x1, y1, x2, y2, width, height;
+ text_getrect(&x->te_g, glist, &x1, &y1, &x2, &y2);
+ width = x2 - x1;
+ height = y2 - y1;
+ if (x->te_type == T_OBJECT)
+ {
+ if (firsttime)
+ sys_vgui(".x%x.c create line\
+ %d %d %d %d %d %d %d %d %d %d -tags %sR\n",
+ glist_getcanvas(glist),
+ x1, y1, x2, y1, x2, y2, x1, y2, x1, y1, tag);
+ else
+ sys_vgui(".x%x.c coords %sR\
+ %d %d %d %d %d %d %d %d %d %d\n",
+ glist_getcanvas(glist), tag,
+ x1, y1, x2, y1, x2, y2, x1, y2, x1, y1);
+ }
+ else if (x->te_type == T_MESSAGE)
+ {
+ if (firsttime)
+ sys_vgui(".x%x.c create line\
+ %d %d %d %d %d %d %d %d %d %d %d %d %d %d -tags %sR\n",
+ glist_getcanvas(glist),
+ x1, y1, x2+4, y1, x2, y1+4, x2, y2-4, x2+4, y2,
+ x1, y2, x1, y1,
+ tag);
+ else
+ sys_vgui(".x%x.c coords %sR\
+ %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n",
+ glist_getcanvas(glist), tag,
+ x1, y1, x2+4, y1, x2, y1+4, x2, y2-4, x2+4, y2,
+ x1, y2, x1, y1);
+ }
+ else if (x->te_type == T_ATOM)
+ {
+ if (firsttime)
+ sys_vgui(".x%x.c create line\
+ %d %d %d %d %d %d %d %d %d %d %d %d -tags %sR\n",
+ glist_getcanvas(glist),
+ x1, y1, x2-4, y1, x2, y1+4, x2, y2, x1, y2, x1, y1,
+ tag);
+ else
+ sys_vgui(".x%x.c coords %sR\
+ %d %d %d %d %d %d %d %d %d %d %d %d\n",
+ glist_getcanvas(glist), tag,
+ x1, y1, x2, y1, x2+4, y1+4, x2+4, y2, x1, y2, x1, y1);
+ }
+ /* draw inlets/outlets */
+
+ if (ob = pd_checkobject(&x->te_pd))
+ glist_drawiofor(glist, ob, firsttime, tag, x1, y1, x2, y2);
+}
+
+void glist_eraseiofor(t_glist *glist, t_object *ob, char *tag)
+{
+ int i, n;
+ n = obj_noutlets(ob);
+ for (i = 0; i < n; i++)
+ sys_vgui(".x%x.c delete %so%d\n",
+ glist_getcanvas(glist), tag, i);
+ n = obj_ninlets(ob);
+ for (i = 0; i < n; i++)
+ sys_vgui(".x%x.c delete %si%d\n",
+ glist_getcanvas(glist), tag, i);
+}
+
+void text_eraseborder(t_text *x, t_glist *glist, char *tag)
+{
+ if (x->te_type == T_TEXT) return;
+ sys_vgui(".x%x.c delete %sR\n",
+ glist_getcanvas(glist), tag);
+ glist_eraseiofor(glist, x, tag);
+}
+
+ /* change text; if T_OBJECT, remake it. LATER we'll have an undo buffer
+ which should be filled in here before making the change. */
+
+void text_setto(t_text *x, t_glist *glist, char *buf, int bufsize)
+{
+ if (x->te_type == T_OBJECT)
+ {
+ t_binbuf *b = binbuf_new();
+ int natom1, natom2;
+ t_atom *vec1, *vec2;
+ binbuf_text(b, buf, bufsize);
+ natom1 = binbuf_getnatom(x->te_binbuf);
+ vec1 = binbuf_getvec(x->te_binbuf);
+ natom2 = binbuf_getnatom(b);
+ vec2 = binbuf_getvec(b);
+ /* special case: if pd args change just pass the message on. */
+ if (natom1 >= 1 && natom2 >= 1 && vec1[0].a_type == A_SYMBOL
+ && !strcmp(vec1[0].a_w.w_symbol->s_name, "pd") &&
+ vec2[0].a_type == A_SYMBOL
+ && !strcmp(vec2[0].a_w.w_symbol->s_name, "pd"))
+ {
+ typedmess(&x->te_pd, gensym("rename"), natom2-1, vec2+1);
+ binbuf_free(x->te_binbuf);
+ x->te_binbuf = b;
+ }
+ else /* normally, just destroy the old one and make a new one. */
+ {
+ int xwas = x->te_xpix, ywas = x->te_ypix;
+ glist_delete(glist, &x->te_g);
+ canvas_objtext(glist, xwas, ywas, 0, b);
+ /* if it's an abstraction loadbang it here */
+ if (newest && pd_class(newest) == canvas_class)
+ canvas_loadbang((t_canvas *)newest);
+ canvas_restoreconnections(glist_getcanvas(glist));
+ }
+ /* if we made a new "pd" or changed a window name,
+ update window list */
+ if (natom2 >= 1 && vec2[0].a_type == A_SYMBOL
+ && !strcmp(vec2[0].a_w.w_symbol->s_name, "pd"))
+ canvas_updatewindowlist();
+ }
+ else binbuf_text(x->te_binbuf, buf, bufsize);
+}
+
+void g_text_setup(void)
+{
+ text_class = class_new(gensym("text"), 0, 0, sizeof(t_text),
+ CLASS_NOINLET | CLASS_PATCHABLE, 0);
+
+ message_class = class_new(gensym("message"), 0, (t_method)message_free,
+ sizeof(t_message), CLASS_PATCHABLE, 0);
+ class_addbang(message_class, message_bang);
+ class_addfloat(message_class, message_float);
+ class_addsymbol(message_class, message_symbol);
+ class_addlist(message_class, message_list);
+ class_addanything(message_class, message_list);
+
+ class_addmethod(message_class, (t_method)message_click, gensym("click"),
+ A_FLOAT, A_FLOAT, A_FLOAT, A_FLOAT, A_FLOAT, 0);
+ class_addmethod(message_class, (t_method)message_set, gensym("set"),
+ A_GIMME, 0);
+ class_addmethod(message_class, (t_method)message_add, gensym("add"),
+ A_GIMME, 0);
+ class_addmethod(message_class, (t_method)message_add2, gensym("add2"),
+ A_GIMME, 0);
+
+ messresponder_class = class_new(gensym("messresponder"), 0, 0,
+ sizeof(t_text), CLASS_PD, 0);
+ class_addbang(messresponder_class, messresponder_bang);
+ class_addfloat(messresponder_class, (t_method) messresponder_float);
+ class_addsymbol(messresponder_class, messresponder_symbol);
+ class_addlist(messresponder_class, messresponder_list);
+ class_addanything(messresponder_class, messresponder_anything);
+
+ gatom_class = class_new(gensym("gatom"), 0, (t_method)gatom_free,
+ sizeof(t_gatom), CLASS_PATCHABLE, 0);
+ class_addbang(gatom_class, gatom_bang);
+ class_addfloat(gatom_class, gatom_float);
+ class_addsymbol(gatom_class, gatom_symbol);
+ class_addmethod(gatom_class, (t_method)gatom_set, gensym("set"),
+ A_GIMME, 0);
+ class_addmethod(gatom_class, (t_method)gatom_click, gensym("click"),
+ A_FLOAT, A_FLOAT, A_FLOAT, A_FLOAT, A_FLOAT, 0);
+ class_addmethod(gatom_class, (t_method)gatom_param, gensym("param"),
+ A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
+ class_setwidget(gatom_class, &gatom_widgetbehavior);
+}
+
+
generated by cgit v1.2.1 (git 2.18.0) at 2024-06-30 10:34:45 +0000