g_editor.c

/* Copyright (c) 2009-2013 Ivica Ico Bukvic and others. Code based on Pure-Data source

Original Pure-Data source copyright (c) 1997-2001 Miller Puckette and others.
* For information on usage and redistribution, and for a DISCLAIMER OF ALL
* WARRANTIES, see the file, "LICENSE.txt," in this distribution.

*/

#include <stdlib.h>
#include <stdio.h>
#include "m_pd.h"
#include "m_imp.h"
#include "s_stuff.h"
#include "g_magicglass.h"
#include "g_canvas.h"
#include "s_utf8.h" /*-- moo --*/
#include "g_undo.h"
#include "x_preset.h"
#include <string.h>
#include "g_all_guis.h"

void glist_readfrombinbuf(t_glist *x, t_binbuf *b, char *filename,
    int selectem);

void open_via_helppath(const char *name, const char *dir);
char *class_gethelpdir(t_class *c);

//static int toggle_moving = 0; //global variable

/* ------------------ forward declarations --------------- */
static void canvas_doclear(t_canvas *x);
void glist_setlastxymod(t_glist *gl, int xval, int yval, int mod);
static void glist_donewloadbangs(t_glist *x);
static t_binbuf *canvas_docopy(t_canvas *x);
static void canvas_dopaste(t_canvas *x, t_binbuf *b);
static void canvas_paste(t_canvas *x);
static void canvas_clearline(t_canvas *x);
static t_binbuf *copy_binbuf;
//static char *canvas_textcopybuf;
//static int canvas_textcopybufsize;
static t_glist *glist_finddirty(t_glist *x);
static void canvas_reselect(t_canvas *x);
static void canvas_cut(t_canvas *x);
static void canvas_undo(t_canvas *x);
static int paste_xyoffset = 0; /* a counter of pastes to make x,y offsets */
//static void canvas_mouseup_gop(t_canvas *x, t_gobj *g);
static void canvas_done_popup(t_canvas *x, t_float which, t_float xpos, t_float ypos);
static void canvas_doarrange(t_canvas *x, t_float which, t_gobj *oldy, t_gobj *oldy_prev, t_gobj *oldy_next);
static void canvas_paste_xyoffset(t_canvas *x);
void canvas_setgraph(t_glist *x, int flag, int nogoprect);
void canvas_mouseup(t_canvas *x, t_floatarg fxpos, t_floatarg fypos, t_floatarg fwhich);
static int outlet_issignal = 0;
static int inlet_issignal = 0;
static int last_inlet_filter = 0;
static int last_outlet_filter = 0;
static int copyfromexternalbuffer = 0;
static int tooltips = 0;
static int objtooltip = 0;
static int screenx1;            /* screen coordinates when doing copyfromexternalbuffer */
static int screeny1;
static int screenx2;
static int screeny2;
static int copiedfont;
static void canvas_dofont(t_canvas *x, t_floatarg font, t_floatarg xresize,
    t_floatarg yresize);
extern void canvas_setbounds(t_canvas *x, int x1, int y1, int x2, int y2);
int canvas_apply_restore_original_position(t_canvas *x, int orig_pos);
extern void canvas_draw_gop_resize_hooks(t_canvas *x);
static void canvas_font(t_canvas *x, t_floatarg font, t_floatarg oldfont, t_floatarg resize, t_floatarg preview);
static void canvas_displaceselection(t_canvas *x, int dx, int dy);
void canvas_motion(t_canvas *x, t_floatarg xpos, t_floatarg ypos, t_floatarg fmod);
// for updating preset_node locations in case of operations that alter glist object locations (tofront/back, cut, delete, undo/redo cut/delete)
extern void glob_preset_node_list_check_loc_and_update(void);
// for preset_node
extern t_class *text_class;

int do_not_redraw = 0;     // used to optimize redrawing
int old_displace = 0;	   // for legacy displaces within gop that are not visible to displaceselection

int connect_exception = 0; // used when autopatching to bypass check whether one is trying to connect signal with non-signal nlet
						   // since this is impossible to figure out when the newly created object is an empty one

// used to test whether the shift is pressed and if so, handle various connection exceptions (e.g. multiconnect)
int glob_lmclick = 0;
int glob_shift = 0;
int glob_ctrl = 0;
int glob_alt = 0;

static t_glist *canvas_last_glist;
static int canvas_last_glist_x, canvas_last_glist_y, canvas_last_glist_mod;

struct _outlet
{
    t_object *o_owner;
    struct _outlet *o_next;
    t_outconnect *o_connections;
    t_symbol *o_sym;
};

/* used for new duplicate behavior where we can "duplicate" into new window */
static t_canvas *c_selection;

/* iemgui uses black inlets and outlets while default objects use gray ones
   add here more as necessary */
int gobj_filter_highlight_behavior(t_rtext *y) {

	char *buf;
	char name[4];
	int bufsize, i;
	rtext_gettext(y, &buf, &bufsize);
	if (bufsize > 3) bufsize = 3;
	for (i = 0; i < bufsize; i++) {
		name[i] = buf[i];
	}
	name[i]='\0';
	//fprintf(stderr,"object name = >%s<\n", name);
	if (!strcmp(name, "bng") ||
		!strcmp(name, "nbx") ||
		!strcmp(name, "hdl") ||
		!strcmp(name, "hsl") ||
		!strcmp(name, "tgl") ||
		!strcmp(name, "vdl") ||
		!strcmp(name, "vsl") ||
		!strcmp(name, "vu ") ||
		/* alternative names for hradio and vradio when invoked from the menu */
		!strcmp(name, "hra") ||
		!strcmp(name, "vra")
		)
		return 1;

	return 0;
}

/* ---------------- generic widget behavior ------------------------- */

void gobj_getrect(t_gobj *x, t_glist *glist, int *x1, int *y1,
    int *x2, int *y2)
{
    if (x->g_pd->c_wb && x->g_pd->c_wb->w_getrectfn)
        (*x->g_pd->c_wb->w_getrectfn)(x, glist, x1, y1, x2, y2);
}

void gobj_displace(t_gobj *x, t_glist *glist, int dx, int dy)
{
    if (x->g_pd->c_wb && x->g_pd->c_wb->w_displacefn)
        (*x->g_pd->c_wb->w_displacefn)(x, glist, dx, dy);
}

void gobj_displace_withtag(t_gobj *x, t_glist *glist, int dx, int dy)
{
    if (x->g_pd->c_wb && x->g_pd->c_wb->w_displacefnwtag)
        (*x->g_pd->c_wb->w_displacefnwtag)(x, glist, dx, dy);
}

void gobj_select(t_gobj *x, t_glist *glist, int state)
{
    if (x->g_pd->c_wb && x->g_pd->c_wb->w_selectfn)
        (*x->g_pd->c_wb->w_selectfn)(x, glist, state);
}

void gobj_activate(t_gobj *x, t_glist *glist, int state)
{
    if (x->g_pd->c_wb && x->g_pd->c_wb->w_activatefn)
        (*x->g_pd->c_wb->w_activatefn)(x, glist, state);
}

void gobj_delete(t_gobj *x, t_glist *glist)
{
    if (x->g_pd->c_wb && x->g_pd->c_wb->w_deletefn)
        (*x->g_pd->c_wb->w_deletefn)(x, glist);
}

int gobj_shouldvis(t_gobj *x, struct _glist *glist)
{
    t_object *ob;
	//fprintf(stderr,"shouldvis %d %d %d %d\n", glist->gl_havewindow, glist->gl_isgraph, glist->gl_goprect, glist->gl_owner != NULL);
    if (!glist->gl_havewindow && glist->gl_isgraph && glist->gl_goprect &&
        glist->gl_owner && (pd_class(&x->g_pd) != scalar_class) && (pd_class(&glist->gl_pd) != garray_class))
    {
        /* if we're graphing-on-parent and the object falls outside the
        graph rectangle, don't draw it. */
        int x1, y1, x2, y2, gx1, gy1, gx2, gy2, m;
        gobj_getrect(&glist->gl_gobj, glist->gl_owner, &x1, &y1, &x2, &y2);
        if (x1 > x2)
            m = x1, x1 = x2, x2 = m;
        if (y1 > y2)
            m = y1, y1 = y2, y2 = m;
        gobj_getrect(x, glist, &gx1, &gy1, &gx2, &gy2);
		//fprintf(stderr,"gobj_shouldvis gop: %d %d %d %d || object %d %d %d %d\n", x1, x2, y1, y2, gx1, gx2, gy1, gy2);
        if (gx1 < x1 || gx1 > x2 || gx2 < x1 || gx2 > x2 ||
            gy1 < y1 || gy1 > y2 || gy2 < y1 || gy2 > y2) {
				//fprintf(stderr,"does not fit within boundaries\n");
                return (0);
		}
		if (glist==glist_getcanvas(glist))
        	sys_vgui(".x%lx.c raise all_cords\n", glist_getcanvas(glist));
    }
    if (ob = pd_checkobject(&x->g_pd))
    {
        /* return true if the text box should be drawn.  We don't show text
        boxes inside graphs---except comments, if we're doing the new
        (goprect) style. */
		//fprintf(stderr,"pd_checkobject %lx\n", x);
		/*fprintf(stderr,"pd_checkobject %d %d %d %d %d %d %d\n",
			glist->gl_havewindow, 
            (ob->te_pd != canvas_class ? 1:0),
			(ob->te_pd->c_wb != &text_widgetbehavior ? 1:0),
			(ob->te_pd == canvas_class ? 1:0),
			((t_glist *)ob)->gl_isgraph,
            glist->gl_goprect,
			(ob->te_type == T_TEXT ? 1:0));*/
		if (sys_k12_mode && x->g_pd == preset_hub_class) {
			//fprintf(stderr,"glist_select do not select invised preset_hub in K12 mode\n");
			t_preset_hub *ph = (t_preset_hub *)x;
			if (ph->ph_invis > 0) return(0);
		}
        return (glist->gl_havewindow ||
            (ob->te_pd != canvas_class &&
                ob->te_pd->c_wb != &text_widgetbehavior) ||
            (ob->te_pd == canvas_class && (((t_glist *)ob)->gl_isgraph)) ||
            (glist->gl_goprect && (ob->te_type == T_TEXT)));
    }
    else {
		//fprintf(stderr,"else return 1\n");
		return (1);
	}
}

void gobj_vis(t_gobj *x, struct _glist *glist, int flag)
{
	if (do_not_redraw) return;
    if (x->g_pd->c_wb && x->g_pd->c_wb->w_visfn && gobj_shouldvis(x, glist))
        (*x->g_pd->c_wb->w_visfn)(x, glist, flag);
}

int gobj_click(t_gobj *x, struct _glist *glist,
    int xpix, int ypix, int shift, int alt, int dbl, int doit)
{
    if (x->g_pd->c_wb && x->g_pd->c_wb->w_clickfn)
        return ((*x->g_pd->c_wb->w_clickfn)(x,
            glist, xpix, ypix, shift, alt, dbl, doit));
    else return (0);
}

/* ------------------------ managing the selection ----------------- */

// direction -1 = lower, 1 = raise
int canvas_restore_original_position(t_glist *x, t_gobj *y, const char* objtag, int dir)
{
	// we do this instead to save us costly redraw of the canvas
	t_object *ob = NULL;
	t_rtext *yrnxt = NULL, *yr = NULL;
	int ret = 0;

	if (y->g_next) {
		ob = pd_checkobject(&y->g_next->g_pd);
	}
	if (ob) {
		yrnxt = glist_findrtext(x, (t_text *)&ob->ob_g);
	}
	if (y) {
		ob = pd_checkobject(&y->g_pd);
	} else {
		ret = 1;
	}
	if (ob) {
		yr = glist_findrtext(x, (t_text *)&ob->ob_g);
	}
	if (ret != 1) {
		if (dir == -1) {
			if (yrnxt) {
				// lower into middle
				if (objtag)
					sys_vgui("pdtk_find_lowest_widget_withtag_and_arrange .x%lx.c %s %s %s\n", x, rtext_gettag(yrnxt), rtext_gettag(yr), objtag);
				else
					sys_vgui("pdtk_find_lowest_widget_withtag_and_arrange .x%lx.c %s %s 0\n", x, rtext_gettag(yrnxt), rtext_gettag(yr));
			} else if (x->gl_list == y) {
				// we get here if we are supposed to go all the way to the bottom
				if (objtag)
					sys_vgui(".x%lx.c addtag arrange withtag %s\n", x, objtag);
				else
					sys_vgui(".x%lx.c addtag arrange withtag selected\n", x);
				sys_vgui(".x%lx.c lower arrange\n", x);
				if (objtag)
					sys_vgui(".x%lx.c dtag %s arrange\n", x, objtag);
				else
					sys_vgui(".x%lx.c dtag selected arrange\n", x);
			} else {
				// fall back to legacy redraw for objects that are not patchable
				canvas_redraw(x);
				ret = -1;
			}
		} else {
			if (yrnxt) {
				// raise into middle
				if (objtag)
					sys_vgui("pdtk_find_lowest_widget_withtag_and_arrange .x%lx.c %s %s %s\n", x, rtext_gettag(yrnxt), rtext_gettag(yr), objtag);
				else
					sys_vgui("pdtk_find_lowest_widget_withtag_and_arrange .x%lx.c %s %s 0\n", x, rtext_gettag(yrnxt), rtext_gettag(yr));
			} else if (y->g_next == NULL) {
				// we get here if we are supposed to go all the way to the top
				if (objtag)
					sys_vgui(".x%lx.c addtag arrange withtag %s\n", x, objtag);
				else
					sys_vgui(".x%lx.c addtag arrange withtag selected\n", x);
				sys_vgui(".x%lx.c raise arrange\n", x);
				if (objtag)
					sys_vgui(".x%lx.c dtag %s arrange\n", x, objtag);
				else
					sys_vgui(".x%lx.c dtag selected arrange\n", x);
				sys_vgui(".x%lx.c raise all_cords\n", x);
			} else {
				// fall back to legacy redraw for objects that are not patchable
				canvas_redraw(x);
				ret = -1;
			}
		}
	}
	return(ret);
}

void canvas_check_nlet_highlights(t_glist *x)
{
	if (x->gl_editor->canvas_cnct_inlet_tag[0] != 0)
	{
		sys_vgui(".x%x.c itemconfigure %s -stroke %s -fill %s -strokewidth 1\n",
		       	x, x->gl_editor->canvas_cnct_inlet_tag,
				(last_inlet_filter ? "black" : (inlet_issignal ? "$signal_cord" : "$msg_cord")),
				(inlet_issignal ? "$signal_nlet" : "$msg_nlet"));
		if (objtooltip) {
			objtooltip = 0;
			sys_vgui("pdtk_canvas_leaveitem .x%x.c;\n", x);
		}
		x->gl_editor->canvas_cnct_inlet_tag[0] = 0;
		//if (x->gl_editor->e_onmotion == MA_CONNECT) {
			x->gl_editor->e_onmotion = MA_NONE;
			canvas_setcursor(x, CURSOR_EDITMODE_NOTHING);
		//}
	}

	if (x->gl_editor->canvas_cnct_outlet_tag[0] != 0 && x->gl_editor->e_onmotion != MA_CONNECT)
	{
		sys_vgui(".x%x.c itemconfigure %s -stroke %s -fill %s -strokewidth 1\n",
		       	x, x->gl_editor->canvas_cnct_outlet_tag,
				(last_outlet_filter ? "black" : (outlet_issignal ? "$signal_cord" : "$msg_cord")),
				(outlet_issignal ? "$signal_nlet" : "$msg_nlet"));
		if (objtooltip) {
			objtooltip = 0;
			sys_vgui("pdtk_canvas_leaveitem .x%x.c;\n", x);
		}
		x->gl_editor->canvas_cnct_outlet_tag[0] = 0;
		//if (x->gl_editor->e_onmotion == MA_CONNECT) {
			x->gl_editor->e_onmotion = MA_NONE;
			canvas_setcursor(x, CURSOR_EDITMODE_NOTHING);
		//}            
	}
}

void glist_selectline(t_glist *x, t_outconnect *oc, int index1,
    int outno, int index2, int inno)
{
    if (x->gl_editor)
    {
        glist_noselect(x);
        x->gl_editor->e_selectedline = 1;
        x->gl_editor->e_selectline_index1 = index1;
        x->gl_editor->e_selectline_outno = outno;
        x->gl_editor->e_selectline_index2 = index2;
        x->gl_editor->e_selectline_inno = inno;
        x->gl_editor->e_selectline_tag = oc;
        sys_vgui(".x%lx.c itemconfigure l%lx -stroke $select_color\n",
            x, x->gl_editor->e_selectline_tag);
        sys_vgui(".x%lx.c addtag selected withtag l%lx\n",
            glist_getcanvas(x), x->gl_editor->e_selectline_tag);
		c_selection = x;
		canvas_draw_gop_resize_hooks(x);
    }
}

void glist_deselectline(t_glist *x)
{
    if (x->gl_editor)
    {
        t_linetraverser t;
        t_outconnect *oc;
        x->gl_editor->e_selectedline = 0;
        linetraverser_start(&t, glist_getcanvas(x));
        do {
            oc = linetraverser_next(&t);
        } while (oc && oc != x->gl_editor->e_selectline_tag);
        int issignal;
        if(outlet_getsymbol(t.tr_outlet) == &s_signal)
            issignal = 1;
        else
            issignal = 0;
        sys_vgui(".x%lx.c itemconfigure l%lx -stroke %s\n",
            x, x->gl_editor->e_selectline_tag,
            (issignal ? "$signal_cord" : "$msg_cord"));
        sys_vgui(".x%lx.c dtag l%lx selected\n",
            glist_getcanvas(x), glist_getcanvas(x)->gl_editor->e_selectline_tag);
		canvas_draw_gop_resize_hooks(x);
    }    
}

int glist_isselected(t_glist *x, t_gobj *y)
{
    if (x->gl_editor)
    {
        t_selection *sel;
        for (sel = x->gl_editor->e_selection; sel; sel = sel->sel_next)
            if (sel->sel_what == y) return (1);
    }
    return (0);
}

    /* call this for unselected objects only */
void glist_select(t_glist *x, t_gobj *y)
{
	//fprintf(stderr,"glist_select c_selection=%lx x=%lx\n", (t_int)c_selection, (t_int)x);
    if (x->gl_editor)
    {
		//fprintf(stderr,"have editor\n");
#ifdef PDL2ORK
		// exception: if we are in K12 mode and preset_hub is hidden, do not select it
		if (sys_k12_mode && y->g_pd == preset_hub_class) {
			//fprintf(stderr,"glist_select do not select invised preset_hub in K12 mode\n");
			t_preset_hub *ph = (t_preset_hub *)y;
			if (ph->ph_invis > 0) return;
		}
#endif
		if (c_selection && c_selection != x) {
			//fprintf(stderr,"deselecting\n");
			glist_noselect(c_selection);
		}
        t_selection *sel = (t_selection *)getbytes(sizeof(*sel));
        if (x->gl_editor->e_selectedline) {
			//fprintf(stderr,"deselecting line\n");
            glist_deselectline(x);
		}
            /* LATER #ifdef out the following check */
        if (glist_isselected(x, y)) bug("glist_select");
        sel->sel_next = x->gl_editor->e_selection;
        sel->sel_what = y;
        x->gl_editor->e_selection = sel;
        gobj_select(y, x, 1);
		c_selection = x;

		sys_vgui("pdtk_canvas_update_edit_menu .x%lx 1\n", x);
		canvas_draw_gop_resize_hooks(x);
    }
	//fprintf(stderr,"select done\n");
}

    /* recursively deselect everything in a gobj "g", if it happens to be
    a glist, in preparation for deselecting g itself in glist_dselect() */
static void glist_checkanddeselectall(t_glist *gl, t_gobj *g)
{
    t_glist *gl2;
    t_gobj *g2;
    if (pd_class(&g->g_pd) != canvas_class)
        return;
    gl2 = (t_glist *)g;
    for (g2 = gl2->gl_list; g2; g2 = g2->g_next)
        glist_checkanddeselectall(gl2, g2);
    glist_noselect(gl2);
}

int glist_getindex(t_glist *x, t_gobj *y);

    /* call this for selected objects only */
void glist_deselect(t_glist *x, t_gobj *y)
{
	//fprintf(stderr, "deselect\n");
    int fixdsp = 0;
    static int reenter = 0;
    /* if (reenter) return; */
    reenter = 1;
    if (x->gl_editor)
    {
        t_selection *sel, *sel2;
        t_rtext *z = 0;
        if (!glist_isselected(x, y)) bug("glist_deselect");
		// following information is for undo_apply
		// we need info on the old object's position
		// in the gl_list so that we can restore it
		int pos = glist_getindex(glist_getcanvas(x), y);
        if (x->gl_editor->e_textedfor)
        {
			//fprintf(stderr, "e_textedfor\n");
            t_rtext *fuddy = glist_findrtext(x, (t_text *)y);
            if (x->gl_editor->e_textedfor == fuddy)
            {
				//fprintf(stderr, "e_textedfor == fuddy\n");
                if (x->gl_editor->e_textdirty)
                {
					//fprintf(stderr, "textdirty yes\n");
                    z = fuddy;
                    canvas_stowconnections(glist_getcanvas(x));
                    glist_checkanddeselectall(x, y);
                }
                gobj_activate(y, x, 0);
            }
            if (zgetfn(&y->g_pd, gensym("dsp")))
                fixdsp = canvas_suspend_dsp();
        }
        if ((sel = x->gl_editor->e_selection)->sel_what == y)
        {
            x->gl_editor->e_selection = x->gl_editor->e_selection->sel_next;
            gobj_select(sel->sel_what, x, 0);
            freebytes(sel, sizeof(*sel));
        }
        else
        {
            for (sel = x->gl_editor->e_selection; sel2 = sel->sel_next;
                sel = sel2)
            {
                if (sel2->sel_what == y)
                {
                    sel->sel_next = sel2->sel_next;
                    gobj_select(sel2->sel_what, x, 0);
                    freebytes(sel2, sizeof(*sel2));
                    break;
                }
            }
        }
        if (z)
        {
			//fprintf(stderr, "setto\n");
            char *buf;
            int bufsize;

            rtext_gettext(z, &buf, &bufsize);
            text_setto((t_text *)y, x, buf, bufsize, pos);
            canvas_fixlinesfor(glist_getcanvas(x), (t_text *)y);
            x->gl_editor->e_textedfor = 0;
        }
        if (fixdsp)
            canvas_resume_dsp(1);
		if (!x->gl_editor->e_selection)
			sys_vgui("pdtk_canvas_update_edit_menu .x%lx 0\n", x);
		canvas_draw_gop_resize_hooks(x);
    }
    reenter = 0;
}

void glist_noselect(t_glist *x)
{
	//fprintf(stderr,"glist_noselect\n");
    if (x->gl_editor)
    {
		if (x->gl_editor->e_selection) {
		    while (x->gl_editor->e_selection)
		        glist_deselect(x, x->gl_editor->e_selection->sel_what);
		}
        if (x->gl_editor->e_selectedline)
            glist_deselectline(x);
		if (c_selection == x)
			c_selection = NULL;
		canvas_draw_gop_resize_hooks(x);
    }
}

void glist_selectall(t_glist *x)
{
    if (x->gl_editor)
    {
        glist_noselect(x);
        if (x->gl_list)
        {
            t_gobj *y = x->gl_list;
#ifdef PDL2ORK
			// exception: if we are in K12 mode and preset_hub is hidden, do not select it
			if (sys_k12_mode && y->g_pd == preset_hub_class) {
				//fprintf(stderr,"glist_select do not select invised preset_hub in K12 mode\n");
				t_preset_hub *ph = (t_preset_hub *)y;
				if (ph->ph_invis > 0) y = y->g_next;
			}
#endif
			if (y) {
		        t_selection *sel = (t_selection *)getbytes(sizeof(*sel));
		        x->gl_editor->e_selection = sel;
		        sel->sel_what = y;
		        gobj_select(y, x, 1);
		        while (y = y->g_next)
		        {
		            t_selection *sel2 = (t_selection *)getbytes(sizeof(*sel2));
		            sel->sel_next = sel2;
		            sel = sel2;
		            sel->sel_what = y;
		            gobj_select(y, x, 1);
		        }
		        sel->sel_next = 0;
				c_selection = x;
			}
        }
		canvas_draw_gop_resize_hooks(x);
    }
}

    /* get the index of a gobj in a glist.  If y is zero, return the
    total number of objects. */
int glist_getindex(t_glist *x, t_gobj *y)
{
    t_gobj *y2;
    int indx;

    for (y2 = x->gl_list, indx = 0; y2 && y2 != y; y2 = y2->g_next)
        indx++;
    return (indx);
}

    /* get the index of the object, among selected items, if "selected"
    is set; otherwise, among unselected ones.  If y is zero, just
    counts the selected or unselected objects. */
int glist_selectionindex(t_glist *x, t_gobj *y, int selected)
{
    t_gobj *y2;
    int indx;

    for (y2 = x->gl_list, indx = 0; y2 && y2 != y; y2 = y2->g_next)
        if (selected == glist_isselected(x, y2))
            indx++;
    return (indx);
}

static t_gobj *glist_nth(t_glist *x, int n)
{
    t_gobj *y;
    int indx;
    for (y = x->gl_list, indx = 0; y; y = y->g_next, indx++)
        if (indx == n)
            return (y);
    return (0);
}

/* ------------------- support for undo/redo  -------------------------- */

static t_undofn canvas_undo_fn;         /* current undo function if any */
static int canvas_undo_whatnext;        /* whether we can now UNDO or REDO */
static void *canvas_undo_buf;           /* data private to the undo function */
static t_canvas *canvas_undo_canvas;    /* which canvas we can undo on */
const char *canvas_undo_name;

void canvas_setundo(t_canvas *x, t_undofn undofn, void *buf,
    const char *name)
{
	//fprintf(stderr,"canvas_setundo %s\n", name);

    int hadone = 0;
        /* blow away the old undo information.  In one special case the
        old undo info is re-used; if so we shouldn't free it here. */
    if (canvas_undo_fn && canvas_undo_buf && (buf != canvas_undo_buf))
    {
		//fprintf(stderr,"hadone canvas_setundo\n");
        (*canvas_undo_fn)(canvas_undo_canvas, canvas_undo_buf, UNDO_FREE);
        hadone = 1;
    }
    canvas_undo_canvas = x;
    canvas_undo_fn = undofn;
    canvas_undo_buf = buf;
    canvas_undo_whatnext = UNDO_UNDO;
    canvas_undo_name = name;
    //if (x && glist_isvisible(x) && glist_istoplevel(x))
	if (x)
    	// enable undo in menu
        sys_vgui("pdtk_undomenu .x%lx %s no\n", x, name);
    else if (hadone)
        sys_vgui("pdtk_undomenu nobody no no\n");
}

    /* clear undo if it happens to be for the canvas x.
     (but if x is 0, clear it regardless of who owns it.) */
void canvas_noundo(t_canvas *x)
{
    if (!x || (x == canvas_undo_canvas))
        canvas_setundo(0, 0, 0, "foo");
}

static void canvas_undo(t_canvas *x)
{
	//fprintf(stderr,"canvas_undo\n");
    if (x != canvas_undo_canvas)
        bug("canvas_undo 1");
    else if (canvas_undo_whatnext != UNDO_UNDO)
        bug("canvas_undo 2");
    else
    {
        //fprintf(stderr,"undo\n");
        (*canvas_undo_fn)(canvas_undo_canvas, canvas_undo_buf, UNDO_UNDO);
            /* enable redo in menu */
        if (glist_isvisible(x) && glist_istoplevel(x))
            sys_vgui("pdtk_undomenu .x%lx no %s\n", x, canvas_undo_name);
        canvas_undo_whatnext = UNDO_REDO;
		sys_vgui("pdtk_canvas_getscroll .x%lx.c\n", x);
    }
}

static void canvas_redo(t_canvas *x)
{
	//fprintf(stderr,"canvas_redo\n");
    if (x != canvas_undo_canvas)
        bug("canvas_redo 1");
    else if (canvas_undo_whatnext != UNDO_REDO)
        bug("canvas_redo 2");
    else
    {
        /* post("redo"); */
        (*canvas_undo_fn)(canvas_undo_canvas, canvas_undo_buf, UNDO_REDO);
            /* enable undo in menu */
        if (glist_isvisible(x) && glist_istoplevel(x))
            sys_vgui("pdtk_undomenu .x%lx %s no\n", x, canvas_undo_name);
        canvas_undo_whatnext = UNDO_UNDO;
		sys_vgui("pdtk_canvas_getscroll .x%lx.c\n", x);
    }
}

/* ------- specific undo methods: 1. connect -------- */

typedef struct _undo_connect    
{
    int u_index1;
    int u_outletno;
    int u_index2;
    int u_inletno;
} t_undo_connect;

void *canvas_undo_set_disconnect(t_canvas *x,
    int index1, int outno, int index2, int inno);

/* connect just calls disconnect actions backward... (see below) */
void *canvas_undo_set_connect(t_canvas *x,
    int index1, int outno, int index2, int inno)
{
    return (canvas_undo_set_disconnect(x, index1, outno, index2, inno));
}

void canvas_undo_connect(t_canvas *x, void *z, int action)
{
    int myaction;
    if (action == UNDO_UNDO)
        myaction = UNDO_REDO;
    else if (action == UNDO_REDO)
        myaction = UNDO_UNDO;
    else myaction = action;
    canvas_undo_disconnect(x, z, myaction);
}

/* ------- specific undo methods: 2. disconnect -------- */

void *canvas_undo_set_disconnect(t_canvas *x,
    int index1, int outno, int index2, int inno)
{
    t_undo_connect *buf = (t_undo_connect *)getbytes(sizeof(*buf));
    buf->u_index1 = index1;
    buf->u_outletno = outno;
    buf->u_index2 = index2;
    buf->u_inletno = inno;
    return (buf);
}

void canvas_disconnect(t_canvas *x,
    t_float index1, t_float outno, t_float index2, t_float inno)
{
	//fprintf(stderr,"canvas_disconnect\n");
    t_linetraverser t;
    t_outconnect *oc;
    linetraverser_start(&t, x);
    while (oc = linetraverser_next(&t))
    {
        int srcno = canvas_getindex(x, &t.tr_ob->ob_g);
        int sinkno = canvas_getindex(x, &t.tr_ob2->ob_g);
        if (srcno == index1 && t.tr_outno == outno &&
            sinkno == index2 && t.tr_inno == inno)
        {
            sys_vgui(".x%lx.c delete l%lx\n", x, oc);
            // jsarlo
			if(x->gl_editor && x->gl_editor->gl_magic_glass) {
            	magicGlass_unbind(x->gl_editor->gl_magic_glass);
            	magicGlass_hide(x->gl_editor->gl_magic_glass);
			}
            // end jsarlo
            obj_disconnect(t.tr_ob, t.tr_outno, t.tr_ob2, t.tr_inno);

			// if we are dealing with a preset_node, make sure to also disconnect its invisible return node
			// we trust here that the object has been already connected to a valid object so we blindly
			// disconnect first outlet with the first inlet (EXCEPTION: print object that cannot be connected back to)
			if (pd_class(&t.tr_ob->ob_g.g_pd) == preset_node_class && pd_class(&t.tr_ob2->ob_g.g_pd) != print_class) {
				//fprintf(stderr,"gotta disconnect hidden one too...\n");
				obj_disconnect(t.tr_ob2, 0, t.tr_ob, 0);
			}
            break;
        }
    }
}

void canvas_undo_disconnect(t_canvas *x, void *z, int action)
{
    t_undo_connect *buf = z;
    if (action == UNDO_UNDO)
    {
        canvas_connect(x, buf->u_index1, buf->u_outletno,
            buf->u_index2, buf->u_inletno);
    }
    else if (action == UNDO_REDO)
    {
        canvas_disconnect(x, buf->u_index1, buf->u_outletno,
            buf->u_index2, buf->u_inletno);
    }
    else if (action == UNDO_FREE)
        t_freebytes(buf, sizeof(*buf));
}

/* ---------- ... 3. cut, clear, and typing into objects: -------- */

#define UCUT_CUT 1          /* operation was a cut */
#define UCUT_CLEAR 2        /* .. a clear */

// following action is not needed any more LATER remove any signs of UCUT_TEXT
// since recreate takes care of this in a more elegant way
#define UCUT_TEXT 3         /* text typed into a box */

typedef struct _undo_cut        
{
    t_binbuf *u_objectbuf;      /* the object cleared or typed into */
    t_binbuf *u_reconnectbuf;   /* connections into and out of object */
    t_binbuf *u_redotextbuf;    /* buffer to paste back for redo if TEXT */
    int u_mode;                 /* from flags above */
	int n_obj;					/* number of selected objects to be cut */
	int p_a[1];					/* array of original glist positions of selected objects */
								/* at least one object is selected, we dynamically resize it later */
} t_undo_cut;

void *canvas_undo_set_cut(t_canvas *x, int mode)
{
    t_undo_cut *buf;
    t_gobj *y;
    t_linetraverser t;
    t_outconnect *oc;
    int nnotsel= glist_selectionindex(x, 0, 0);
	int nsel = glist_selectionindex(x, 0, 1);
    buf = (t_undo_cut *)getbytes(sizeof(*buf) + sizeof(buf->p_a[0]) * (nsel - 1));
	buf->n_obj = nsel;
    buf->u_mode = mode;
    buf->u_redotextbuf = 0;

        /* store connections into/out of the selection */
    buf->u_reconnectbuf = binbuf_new();
    linetraverser_start(&t, x);
	//if (linetraverser_next(&t)) {
	while (oc = linetraverser_next(&t))
	{
	    int issel1 = glist_isselected(x, &t.tr_ob->ob_g);
	    int issel2 = glist_isselected(x, &t.tr_ob2->ob_g);
	    if (issel1 != issel2)
	    {
	        binbuf_addv(buf->u_reconnectbuf, "ssiiii;",
	            gensym("#X"), gensym("connect"),
	            (issel1 ? nnotsel : 0)
	                + glist_selectionindex(x, &t.tr_ob->ob_g, issel1),
	            t.tr_outno,
	            (issel2 ? nnotsel : 0) +
	                glist_selectionindex(x, &t.tr_ob2->ob_g, issel2),
	            t.tr_inno);
	    }
	}
	//}
    if (mode == UCUT_TEXT)
    {
        buf->u_objectbuf = canvas_docopy(x);
    }
    else if (mode == UCUT_CUT)
    {
        buf->u_objectbuf = canvas_docopy(x);
    }
    else if (mode == UCUT_CLEAR)
    {
        buf->u_objectbuf = canvas_docopy(x);
    }

	//instantiate num_obj and fill array of positions of selected objects
	if (mode == UCUT_CUT || mode == UCUT_CLEAR)
	{
		int i = 0, j = 0;
		if (x->gl_list) {
			for (y = x->gl_list; y; y = y->g_next)
			{
				if (glist_isselected(x, y)) {
					buf->p_a[i] = j;
					i++;
				}
				j++;
			}
		}
		//for (i = 0; i < buf->n_obj; i++)
		//	fprintf(stderr,"%d position = %d\n", i, buf->p_a[i]);
	}

    return (buf);
}

void canvas_undo_cut(t_canvas *x, void *z, int action)
{
	//fprintf(stderr, "canvas_undo_cut canvas=%d buf=%d action=%d\n", (int)x, (int)z, action);
    t_undo_cut *buf = z;
    int mode = buf->u_mode;
    if (action == UNDO_UNDO)
    {
		do_not_redraw += 1;
		//fprintf(stderr,"UNDO_UNDO\n");
        if (mode == UCUT_CUT) {
			//fprintf(stderr, "UCUT_CUT\n");
            canvas_dopaste(x, buf->u_objectbuf);
		}
        else if (mode == UCUT_CLEAR) {
			//fprintf(stderr, "UCUT_CLEAR\n");
            canvas_dopaste(x, buf->u_objectbuf);
		}
        else if (mode == UCUT_TEXT)
        {
			//fprintf(stderr, "UCUT_TEXT\n");
            t_gobj *y1, *y2;
            glist_noselect(x);
            for (y1 = x->gl_list; y2 = y1->g_next; y1 = y2)
                ;
            if (y1)
            {
                if (!buf->u_redotextbuf)
                {
                    glist_noselect(x);
                    glist_select(x, y1);
                    buf->u_redotextbuf = canvas_docopy(x);
                    glist_noselect(x);
                }
                glist_delete(x, y1);
            }
            canvas_dopaste(x, buf->u_objectbuf);
        }
        pd_bind(&x->gl_pd, gensym("#X"));
        binbuf_eval(buf->u_reconnectbuf, 0, 0, 0);
        pd_unbind(&x->gl_pd, gensym("#X"));

		//now reposition objects to their original locations
		if (mode == UCUT_CUT || mode == UCUT_CLEAR) {
			//fprintf(stderr,"reordering\n");
			int i = 0;
			int paste_pos = glist_getindex(x,0) - buf->n_obj; //location of the first newly pasted object
			//fprintf(stderr,"paste_pos %d\n", paste_pos);
			t_gobj *y_prev, *y, *y_next;
			for (i = 0; i < buf->n_obj; i++) {
				//first check if we are in the same position already
				if (paste_pos+i != buf->p_a[i]) {
					//fprintf(stderr,"not in the right place\n");
					y_prev = glist_nth(x, paste_pos-1+i);
					y = glist_nth(x, paste_pos+i);
					y_next = glist_nth(x, paste_pos+1+i);
					//if the object is supposed to be first in the gl_list
					if (buf->p_a[i] == 0) {
						if (y_prev && y_next) {
							y_prev->g_next = y_next;
						}
						else if (y_prev && !y_next)
							y_prev->g_next = NULL;
						//now put the moved object at the beginning of the cue
						y->g_next = glist_nth(x, 0);
						x->gl_list = y;
						//LATER when objects are properly tagged lower y here
					}
					//if the object is supposed to be at the current end of gl_list	
					//can this ever happen???
					/*else if (!glist_nth(x,buf->p_a[i])) {

					}*/
					//if the object is supposed to be in the middle of gl_list
					else {
						if (y_prev && y_next) {
							y_prev->g_next = y_next;
						}
						else if (y_prev && !y_next) {
							y_prev->g_next = NULL;
						}
						//now put the moved object in its right place
						y_prev = glist_nth(x, buf->p_a[i]-1);
						y_next = glist_nth(x, buf->p_a[i]);

						y_prev->g_next = y;
						y->g_next = y_next;
						//LATER when objects are properly tagged lower y here
					}
				}
			}
			do_not_redraw -= 1;
			//LATER disable redrawing here
			canvas_redraw(x);
			if (x->gl_owner && glist_isvisible(x->gl_owner)) {
				gobj_vis((t_gobj *)x, x->gl_owner, 0);
				gobj_vis((t_gobj *)x, x->gl_owner, 1);
			}
			glob_preset_node_list_check_loc_and_update();
		}
    }
    else if (action == UNDO_REDO)
    {
		//fprintf(stderr,"UNDO_REDO\n");
        if (mode == UCUT_CUT || mode == UCUT_CLEAR) {
			//we can't just blindly do clear here when the user may have
			//unselected things between undo and redo, so first let's select
			//the right stuff
			glist_noselect(x);
			int i = 0;
			for (i = 0; i < buf->n_obj; i++)
            	glist_select(x, glist_nth(x, buf->p_a[i]));
            canvas_doclear(x);
			glob_preset_node_list_check_loc_and_update();
		}
        else if (mode == UCUT_TEXT)
        {
            t_gobj *y1, *y2;
            for (y1 = x->gl_list; y2 = y1->g_next; y1 = y2)
                ;
            if (y1)
                glist_delete(x, y1);
            canvas_dopaste(x, buf->u_redotextbuf);
            pd_bind(&x->gl_pd, gensym("#X"));
            binbuf_eval(buf->u_reconnectbuf, 0, 0, 0);
            pd_unbind(&x->gl_pd, gensym("#X"));
        }
    }
    else if (action == UNDO_FREE)
    {
		//fprintf(stderr,"UNDO_FREE\n");
        if (buf->u_objectbuf)
            binbuf_free(buf->u_objectbuf);
        if (buf->u_reconnectbuf)
            binbuf_free(buf->u_reconnectbuf);
        if (buf->u_redotextbuf)
            binbuf_free(buf->u_redotextbuf);
        if (buf != NULL) t_freebytes(buf, sizeof(*buf) + sizeof(buf->p_a[0]) * (buf->n_obj-1));
    }
}

/* --------- 4. motion, including "tidy up" and stretching ----------- */

typedef struct _undo_move_elem  
{
    int e_index;
    int e_xpix;
    int e_ypix;
} t_undo_move_elem;

typedef struct _undo_move       
{
    t_undo_move_elem *u_vec;
    int u_n;
} t_undo_move;

static int canvas_undo_already_set_move;

void *canvas_undo_set_move(t_canvas *x, int selected)
{
    int x1, y1, x2, y2, i, indx;
    t_gobj *y;
    t_undo_move *buf =  (t_undo_move *)getbytes(sizeof(*buf));
    buf->u_n = selected ? glist_selectionindex(x, 0, 1) : glist_getindex(x, 0);
    buf->u_vec = (t_undo_move_elem *)getbytes(sizeof(*buf->u_vec) *
        (selected ? glist_selectionindex(x, 0, 1) : glist_getindex(x, 0)));
    if (selected)
    {
        for (y = x->gl_list, i = indx = 0; y; y = y->g_next, indx++)
            if (glist_isselected(x, y))
        {
            gobj_getrect(y, x, &x1, &y1, &x2, &y2);
            buf->u_vec[i].e_index = indx;
            buf->u_vec[i].e_xpix = x1;
            buf->u_vec[i].e_ypix = y1;
            i++;
        }
    }
    else
    {
        for (y = x->gl_list, indx = 0; y; y = y->g_next, indx++)
        {
            gobj_getrect(y, x, &x1, &y1, &x2, &y2);
            buf->u_vec[indx].e_index = indx;
            buf->u_vec[indx].e_xpix = x1;
            buf->u_vec[indx].e_ypix = y1;
        }
    }
    canvas_undo_already_set_move = 1;
    return (buf);
}

void canvas_undo_move(t_canvas *x, void *z, int action)
{
    t_undo_move *buf = z;
	t_class *cl;
	int resortin = 0, resortout = 0;
    if (action == UNDO_UNDO || action == UNDO_REDO)
    {
        int i;
        int x1=0, y1=0, x2=0, y2=0, newx=0, newy=0;
        t_gobj *y;
		//do_not_redraw = 1;
        for (i = 0; i < buf->u_n; i++)
        {
            y = glist_nth(x, buf->u_vec[i].e_index);
			newx = buf->u_vec[i].e_xpix;
			newy = buf->u_vec[i].e_ypix;
            if (y)
            {
				glist_noselect(x);
				glist_select(x, y);
	            gobj_getrect(y, x, &x1, &y1, &x2, &y2);
				canvas_displaceselection(x, newx-x1, newy - y1);
				buf->u_vec[i].e_xpix = x1;
				buf->u_vec[i].e_ypix = y1;
				cl = pd_class(&y->g_pd);
		        if (cl == vinlet_class) resortin = 1;
		        else if (cl == voutlet_class) resortout = 1;
            }
        }
		glist_noselect(x);
        for (i = 0; i < buf->u_n; i++)
        {
			y = glist_nth(x, buf->u_vec[i].e_index);
			glist_select(x, y);
		}
		//do_not_redraw = 0;
		//canvas_redraw(x);
		if (resortin) canvas_resortinlets(x);
		if (resortout) canvas_resortoutlets(x);
    }
    else if (action == UNDO_FREE)
    {
        t_freebytes(buf->u_vec, buf->u_n * sizeof(*buf->u_vec));
        t_freebytes(buf, sizeof(*buf));
    }
}

/* --------- 5. paste (also duplicate) ----------- */

typedef struct _undo_paste      
{
    int u_index;    		/* index of first object pasted */
	int u_sel_index; 		/* index of object selected at the time the other object was pasted (for autopatching) */
	int u_offset;			/* offset for duplicated items (since it differs when duplicated into same or different canvas */ 
	t_binbuf *u_objectbuf;	/* here we store actual copied data */
} t_undo_paste;

void *canvas_undo_set_paste(t_canvas *x, int offset, int duplicate, int d_offset)
{
    t_undo_paste *buf =  (t_undo_paste *)getbytes(sizeof(*buf));
    buf->u_index = glist_getindex(x, 0) - offset; //do we need offset at all?
	if (!duplicate && x->gl_editor->e_selection && !x->gl_editor->e_selection->sel_next) {
		//if only one object is selected which will warrant autopatching
		buf->u_sel_index = glist_getindex(x, x->gl_editor->e_selection->sel_what);
		//fprintf(stderr,"canvas_undo_set_paste selected object index %d\n", buf->u_sel_index);
	} else {
		buf->u_sel_index = -1;
	}
	buf->u_offset = d_offset;
	buf->u_objectbuf = binbuf_duplicate(copy_binbuf);
    return (buf);
}

void canvas_undo_paste(t_canvas *x, void *z, int action)
{
    t_undo_paste *buf = z;
    if (action == UNDO_UNDO)
    {
        t_gobj *y;
        glist_noselect(x);
        for (y = glist_nth(x, buf->u_index); y; y = y->g_next)
            glist_select(x, y);
        canvas_doclear(x);
    }
    else if (action == UNDO_REDO)
    {
		//if (buf->u_offset)
		//	do_not_redraw += 1;
        t_selection *sel;
		glist_noselect(x);
		//if the pasted object is supposed to be autopatched
		//then select the object it should be autopatched to
		if (buf->u_sel_index > -1) {
			//fprintf(stderr,"undo trying autopatch\n");
			glist_select(x, glist_nth(x, buf->u_sel_index));
		}
        canvas_dopaste(x, buf->u_objectbuf);
            /* if it was "duplicate" have to re-enact the displacement. */
        if (buf->u_offset) {
			//do_not_redraw -= 1;
            //for (sel = x->gl_editor->e_selection; sel; sel = sel->sel_next)
            //    gobj_displace(sel->sel_what, x, 10, 10);
			canvas_paste_xyoffset(x);
		}
    }
	else if (action == UNDO_FREE) {
        if (buf->u_objectbuf)
            binbuf_free(buf->u_objectbuf);
        t_freebytes(buf, sizeof(*buf));
	}
}

    /* recursively check for abstractions to reload as result of a save. 
    Don't reload the one we just saved ("except") though. */
    /*  LATER try to do the same trick for externs. */
static void glist_doreload(t_glist *gl, t_symbol *name, t_symbol *dir,
    t_gobj *except)
{
	//fprintf(stderr,"doreload\n");
    t_gobj *g;
    int i, nobj = glist_getindex(gl, 0);  /* number of objects */
    int hadwindow = gl->gl_havewindow;
	int found = 0;
	// to optimize redrawing we select all objects that need to be updated and redraw them together
	// then we look for sub-patches that may have more of the same...
    for (g = gl->gl_list, i = 0; g && i < nobj; i++)
    {
        if (g != except && pd_class(&g->g_pd) == canvas_class &&
            canvas_isabstraction((t_canvas *)g) &&
                ((t_canvas *)g)->gl_name == name &&
                    canvas_getdir((t_canvas *)g) == dir)
        {
                /* we're going to remake the object, so "g" will go stale.
                Get its index here, and afterward restore g.  Also, the
                replacement will be at the end of the list, so we don't
                do g = g->g_next in this case. */
            int j = glist_getindex(gl, g);
			//fprintf(stderr, "rebuildlicious %d\n", j);
            if (!gl->gl_havewindow) {
                canvas_vis(glist_getcanvas(gl), 1);
				//fprintf(stderr,"calling canvas_vis\n");
			}
			if (!found) {
				glist_noselect(gl);
				found = 1;
			}
            glist_select(gl, g);
            //canvas_setundo(gl, canvas_undo_cut,
            //    canvas_undo_set_cut(gl, UCUT_CLEAR), "clear");
			//canvas_undo_add(gl, 3, "clear", canvas_undo_set_cut(gl, UCUT_CLEAR));

			//canvas_cut(gl);
			//canvas_undo_undo(gl);
			//glist_noselect(gl);
            //g = glist_nth(gl, j+1);
        }
		g = g->g_next;
	}
	if (found) {
		canvas_cut(gl);
		canvas_undo_undo(gl);
		//canvas_undo_rebranch(gl);
		glist_noselect(gl);
	}

	// now look for sub-patches...
    for (g = gl->gl_list, i = 0; g && i < nobj; i++)
    {
        if (g != except && pd_class(&g->g_pd) == canvas_class &&

            (!canvas_isabstraction((t_canvas *)g) ||
                 ((t_canvas *)g)->gl_name != name ||
                 canvas_getdir((t_canvas *)g) != dir)
		   )
                glist_doreload((t_canvas *)g, name, dir, except);
        g = g->g_next;
    }
    if (!hadwindow && gl->gl_havewindow)
        canvas_vis(glist_getcanvas(gl), 0);
}

    /* this flag stops canvases from being marked "dirty" if we have to touch
    them to reload an abstraction; also suppress window list update */
int glist_amreloadingabstractions = 0;

    /* call canvas_doreload on everyone */
void canvas_reload(t_symbol *name, t_symbol *dir, t_gobj *except)
{
    t_canvas *x;
    int dspwas = canvas_suspend_dsp();
    glist_amreloadingabstractions = 1;
        /* find all root canvases */
    for (x = canvas_list; x; x = x->gl_next)
        glist_doreload(x, name, dir, except);
    glist_amreloadingabstractions = 0;
    canvas_resume_dsp(dspwas);
}

/* --------- 6. apply  ----------- */

typedef struct _undo_apply        
{
    t_binbuf *u_objectbuf;      /* the object cleared or typed into */
    t_binbuf *u_reconnectbuf;   /* connections into and out of object */
	int u_index;				/* index of the previous object */
} t_undo_apply;

void *canvas_undo_set_apply(t_canvas *x, int n)
{
    t_undo_apply *buf;
    t_gobj *y, *obj;