g_editor.c

/* 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 "g_undo.h"
#include <string.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);
static void glist_setlastxy(t_glist *gl, int xval, int yval);
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);
static char canvas_cnct_inlet_tag[4096];
static char canvas_cnct_outlet_tag[4096];
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 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);
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);
	for (i = 0; i < 3; i++) {
		name[i] = buf[i];
	}
	name[3]='\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\n");
    if (!glist->gl_havewindow && glist->gl_isgraph && glist->gl_goprect &&
        glist->gl_owner && (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);
        if (gx1 < x1 || gx1 > x2 || gx2 < x1 || gx2 > x2 ||
            gy1 < y1 || gy1 > y2 || gy2 < y1 || gy2 > y2)
                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. */
        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 return (1);
}

void gobj_vis(t_gobj *x, struct _glist *glist, int flag)
{
    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 ----------------- */

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 -fill $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;
    }
}

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 -fill %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);
    }    
}

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\n");
    if (x->gl_editor)
    {
		if (c_selection && c_selection != x)
			glist_noselect(c_selection);
        t_selection *sel = (t_selection *)getbytes(sizeof(*sel));
        if (x->gl_editor->e_selectedline)
            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);
    }
}

    /* 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);
}

    /* 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");
        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);
            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);
    }
    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;
    }
}

void glist_selectall(t_glist *x)
{
    if (x->gl_editor)
    {
        glist_noselect(x);
        if (x->gl_list)
        {
            t_selection *sel = (t_selection *)getbytes(sizeof(*sel));
            t_gobj *y = x->gl_list;
            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;
        }
    }
}

    /* 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)
{
    if (x != canvas_undo_canvas)
        bug("canvas_undo 1");
    else if (canvas_undo_whatnext != UNDO_REDO)
        bug("canvas_undo 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)
{
    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_magic_glass) {
            	magicGlass_unbind(x->gl_magic_glass);
            	magicGlass_hide(x->gl_magic_glass);
			}
            // end jsarlo
            obj_disconnect(t.tr_ob, t.tr_outno, t.tr_ob2, t.tr_inno);
            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 */
#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 = 0;
    }
    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)
    {
		//fprintf(stderr,"UNDO_UNDO\n");
        if (mode == UCUT_CUT) {
			//fprintf(stderr, "UCUT_CUT\n");
            canvas_dopaste(x, copy_binbuf);
		}
        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;
					}
					//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;
					}
				}
				canvas_redraw(x);
			}
		}
    }
    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);
		}
        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;
        for (i = 0; i < buf->u_n; i++)
        {
            int x1, y1, x2, y2, newx, newy;
            t_gobj *y;
            newx = buf->u_vec[i].e_xpix;
            newy = buf->u_vec[i].e_ypix;
            y = glist_nth(x, buf->u_vec[i].e_index);
            if (y)
            {
                gobj_getrect(y, x, &x1, &y1, &x2, &y2);
                gobj_displace(y, 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;
            }
        }
		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) */ 
	t_binbuf *u_objectbuf;	/* here we store actual copied data */
} t_undo_paste;

void *canvas_undo_set_paste(t_canvas *x, int 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 (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_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)
    {
        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)
			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 (canvas_undo_name && canvas_undo_name[0] == 'd')
            //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;
    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. */
			//fprintf(stderr, "rebuildlicious\n");
            int j = glist_getindex(gl, g);
            if (!gl->gl_havewindow)
                canvas_vis(glist_getcanvas(gl), 1);
            glist_noselect(gl);
            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_doclear(gl);
            canvas_undo(gl);
            glist_noselect(gl);
            g = glist_nth(gl, j);
        }
        else
        {
            if (g != except && pd_class(&g->g_pd) == canvas_class)
                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;

static void *canvas_undo_set_apply(t_canvas *x, int n)
{
    t_undo_apply *buf;
    t_gobj *y, *obj;
    t_linetraverser t;
    t_outconnect *oc;
	/* enable editor (in case it is disabled) and select the object we are working on */
	if (!x->gl_edit)
		canvas_editmode(x, 1);
	obj = glist_nth(x, n);
	if (!glist_isselected(x, obj))
		glist_select(x, obj);
    int nnotsel= glist_selectionindex(x, 0, 0); /* get number of all items for the offset below */
    buf = (t_undo_apply *)getbytes(sizeof(*buf));

    /* store connections into/out of the selection */
    buf->u_reconnectbuf = binbuf_new();
    linetraverser_start(&t, x);
    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);
        }
    }
	/* copy object in its current state */
    buf->u_objectbuf = canvas_docopy(x);

	/* store index of the currently selected object */
	buf->u_index = n;

    return (buf);
}

static void canvas_undo_apply(t_canvas *x, void *z, int action)
{
    t_undo_apply *buf = z;
    if (action == UNDO_UNDO || action == UNDO_REDO)
    {
		/* find current instance */
		glist_noselect(x);
		glist_select(x, glist_nth(x, buf->u_index));

		/* copy it for the new undo/redo */
		t_binbuf *tmp = canvas_docopy(x);

		/* delete current instance */
		canvas_doclear(x);

		/* replace it with previous instance */
        canvas_dopaste(x, buf->u_objectbuf);

		/* change previous instance with current one */
		//TODO: test this		
		buf->u_objectbuf = tmp;
		//buf->u_index = glist_selectionindex(x, 0, 0);

		/* connections should stay the same */
        pd_bind(&x->gl_pd, gensym("#X"));
        binbuf_eval(buf->u_reconnectbuf, 0, 0, 0);
        pd_unbind(&x->gl_pd, gensym("#X"));

		//now we need to reposition the object to its original place
		t_gobj *y, *y_prev, *y_next;
		//get the last object
		y = glist_nth(x, glist_getindex(x, 0) - 1);
		/*for (y = x->gl_list; y; y = y->g_next)
			if (!y->g_next)
				break;*/
		if (glist_getindex(x, y) != buf->u_index) {
			//fprintf(stderr,"not in the right place\n");
			y_prev = glist_nth(x, buf->u_index-1);
			y_next = glist_nth(x, buf->u_index);
			//if the object is supposed to be first in the gl_list
			if (buf->u_index == 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;
			}
			//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->u_index-1);
				y_next = glist_nth(x, buf->u_index);

				y_prev->g_next = y;
				y->g_next = y_next;
			}
		}
    }
    else if (action == UNDO_FREE)
    {
        if (buf->u_objectbuf)
            binbuf_free(buf->u_objectbuf);
        if (buf->u_reconnectbuf)
            binbuf_free(buf->u_reconnectbuf);
        t_freebytes(buf, sizeof(*buf));
    }
}

void canvas_apply_setundo(t_canvas *x, int n)
{
	canvas_setundo(x, canvas_undo_apply, canvas_undo_set_apply(x, n), "apply");
}

/* --------- 7. arrange (to front/back)  ----------- */

typedef struct _undo_arrange       
{
	int u_previndex;			/* old index */
	int u_newindex;				/* new index */
} t_undo_arrange;

static void *canvas_undo_set_arrange(t_canvas *x, t_gobj *obj, int newindex)
{
	// newindex tells us is the new index at the beginning (0) or the end (1)

    t_undo_arrange *buf;
    t_gobj *y;
	/* enable editor (in case it is disabled) and select the object we are working on */
	if (!x->gl_edit)
		canvas_editmode(x, 1);

	// select the object
	if (!glist_isselected(x, obj))
		glist_select(x, obj);

    buf = (t_undo_arrange *)getbytes(sizeof(*buf));

	// set the u_newindex appropriately
	if (newindex == 0) buf->u_newindex = 0;
	else buf->u_newindex = glist_getindex(x, 0) - 1;

	/* store index of the currently selected object */
	buf->u_previndex = glist_getindex(x, obj);

	//fprintf(stderr,"undo_set_arrange %d %d\n", buf->u_previndex, buf->u_newindex);		

    return (buf);
}

static void canvas_undo_arrange(t_canvas *x, void *z, int action)
{
    t_undo_arrange *buf = z;
	t_gobj *y=NULL, *prev=NULL, *next=NULL;

	if (!x->gl_edit)
		canvas_editmode(x, 1);

    if (action == UNDO_UNDO)
    {
		// this is our object
		y = glist_nth(x, buf->u_newindex);

		//fprintf(stderr,"canvas_undo_arrange UNDO_UNDO %d %d\n", buf->u_previndex, buf->u_newindex);		

		/* select object */
		glist_noselect(x);
		glist_select(x, y);

		if (buf->u_newindex) {
			// if it is the last object
			
			// first previous object should point to nothing
			prev = glist_nth(x, buf->u_newindex - 1);
			prev->g_next = NULL;	

			/* now we reuse vars for the follwoing:
			   old index should be right before the object previndex
			   is pointing to as the object was moved to the end */

			/* old position is not first */
			if (buf->u_previndex) {
				prev = glist_nth(x, buf->u_previndex - 1);
				next = prev->g_next;

				// now readjust pointers
				prev->g_next = y;
				y->g_next = next;
			}
			/* old position is first */
			else {
				prev = NULL;
				next = x->gl_list;

				// now readjust pointers
				y->g_next = next;
				x->gl_list = y;
			}

			// and finally redraw canvas
			canvas_redraw(x);
		}
		else {
			// if it is the first object

			/* old index should be right after the object previndex
			   is pointing to as the object was moved to the end */
			prev = glist_nth(x, buf->u_previndex);

			// next may be NULL and that is ok
			next = prev->g_next;

			//first glist pointer needs to point to the second object
			x->gl_list = y->g_next;

			//now readjust pointers
			prev->g_next = y;
			y->g_next = next;

			// and finally redraw canvas
			canvas_redraw(x);
		}
    }
	else if (action == UNDO_REDO) {
		// find our object
		y = glist_nth(x, buf->u_previndex);

		//fprintf(stderr,"canvas_undo_arrange UNDO_REDO %d %d\n", buf->u_previndex, buf->u_newindex);	

		/* select object */
		glist_noselect(x);
		glist_select(x, y);

		int action;
		if (!buf->u_newindex) action = 4;
		else action = 3;

		t_gobj *oldy_prev=NULL, *oldy_next=NULL;

		// if there is an object before ours (in other words our index is > 0)
		if (glist_getindex(x,y))
			oldy_prev = glist_nth(x, buf->u_previndex - 1);
			
		// if there is an object after ours
		if (y->g_next)
			oldy_next = y->g_next;

		canvas_doarrange(x, action, y, oldy_prev, oldy_next);
	}
    else if (action == UNDO_FREE)
    {
        t_freebytes(buf, sizeof(*buf));
    }
}

void canvas_arrange_setundo(t_canvas *x, t_gobj *obj, int newindex)
{
	canvas_setundo(x, canvas_undo_arrange, canvas_undo_set_arrange(x, obj, newindex), "arrange");
}

/* --------- 8. apply on canvas ----------- */

typedef struct _undo_canvas_properties      
{
    int gl_pixwidth;            /* width in pixels (on parent, if a graph) */
    int gl_pixheight;
    t_float gl_x1;                /* bounding rectangle in our own coordinates */
    t_float gl_y1;
    t_float gl_x2;
    t_float gl_y2;
    int gl_screenx1;            /* screen coordinates when toplevel */
    int gl_screeny1;
    int gl_screenx2;
    int gl_screeny2;
    int gl_xmargin;                /* origin for GOP rectangle */
    int gl_ymargin;

    unsigned int gl_goprect:1;      /* draw rectangle for graph-on-parent */
    unsigned int gl_isgraph:1;      /* show as graph on parent */
    unsigned int gl_hidetext:1;     /* hide object-name + args when doing graph on parent */
} t_undo_canvas_properties;

t_undo_canvas_properties global_buf;

static void *canvas_undo_set_canvas(t_canvas *x)
{
	/* enable editor (in case it is disabled) */
	//if (x->gl_havewindow && !x->gl_edit)
	//	canvas_editmode(x, 1);

	global_buf.gl_pixwidth = x->gl_pixwidth;
	global_buf.gl_pixheight = x->gl_pixheight;
	global_buf.gl_x1 = x->gl_x1;
	global_buf.gl_y1 = x->gl_y1;
	global_buf.gl_x2 = x->gl_x2;
	global_buf.gl_y2 = x->gl_y2;
	global_buf.gl_screenx1 = x->gl_screenx1;
	global_buf.gl_screeny1 = x->gl_screeny1;
	global_buf.gl_screenx2 = x->gl_screenx2;
	global_buf.gl_screeny2 = x->gl_screeny2;
	global_buf.gl_xmargin = x->gl_xmargin;
	global_buf.gl_ymargin = x->gl_ymargin;
	global_buf.gl_goprect = x->gl_goprect;
	global_buf.gl_isgraph = x->gl_isgraph;
	global_buf.gl_hidetext = x->gl_hidetext;
	
    return (&global_buf);
}

extern int gfxstub_haveproperties(void *key);

static void canvas_undo_canvas_apply(t_canvas *x, void *z, int action)
{
    t_undo_canvas_properties *buf = z;
    t_undo_canvas_properties tmp;

	if (!x->gl_edit)
		canvas_editmode(x, 1);

	if (action == UNDO_UNDO || action == UNDO_REDO)
	{
		/*//close properties window first
		t_int properties = gfxstub_haveproperties((void *)x);
		if (properties) {
			sys_vgui("destroy .gfxstub%lx\n", properties);
		}*/

		//store current canvas values into temporary data holder
		tmp.gl_pixwidth = x->gl_pixwidth;
		tmp.gl_pixheight = x->gl_pixheight;
		tmp.gl_x1 = x->gl_x1;
		tmp.gl_y1 = x->gl_y1;
		tmp.gl_x2 = x->gl_x2;
		tmp.gl_y2 = x->gl_y2;
		tmp.gl_screenx1 = x->gl_screenx1;
		tmp.gl_screeny1 = x->gl_screeny1;
		tmp.gl_screenx2 = x->gl_screenx2;
		tmp.gl_screeny2 = x->gl_screeny2;
		tmp.gl_xmargin = x->gl_xmargin;
		tmp.gl_ymargin = x->gl_ymargin;
		tmp.gl_goprect = x->gl_goprect;
		tmp.gl_isgraph = x->gl_isgraph;
		tmp.gl_hidetext = x->gl_hidetext;

		//change canvas values with the ones from the undo buffer
		x->gl_pixwidth = buf->gl_pixwidth;
		x->gl_pixheight = buf->gl_pixheight;
		x->gl_x1 = buf->gl_x1;
		x->gl_y1 = buf->gl_y1;
		x->gl_x2 = buf->gl_x2;
		x->gl_y2 = buf->gl_y2;
		x->gl_screenx1 = buf->gl_screenx1;
		x->gl_screeny1 = buf->gl_screeny1;
		x->gl_screenx2 = buf->gl_screenx2;
		x->gl_screeny2 = buf->gl_screeny2;
		x->gl_xmargin = buf->gl_xmargin;
		x->gl_ymargin = buf->gl_ymargin;
		x->gl_goprect = buf->gl_goprect;
		x->gl_isgraph = buf->gl_isgraph;
		x->gl_hidetext = buf->gl_hidetext;

		//copy data values from the temporary data to the undo buffer
		buf->gl_pixwidth = tmp.gl_pixwidth;
		buf->gl_pixheight = tmp.gl_pixheight;
		buf->gl_x1 = tmp.gl_x1;
		buf->gl_y1 = tmp.gl_y1;
		buf->gl_x2 = tmp.gl_x2;
		buf->gl_y2 = tmp.gl_y2;
		buf->gl_screenx1 = tmp.gl_screenx1;
		buf->gl_screeny1 = tmp.gl_screeny1;
		buf->gl_screenx2 = tmp.gl_screenx2;
		buf->gl_screeny2 = tmp.gl_screeny2;
		buf->gl_xmargin = tmp.gl_xmargin;
		buf->gl_ymargin = tmp.gl_ymargin;
		buf->gl_goprect = tmp.gl_goprect;
		buf->gl_isgraph = tmp.gl_isgraph;
		buf->gl_hidetext = tmp.gl_hidetext;

		//redraw
		canvas_setgraph(x, x->gl_isgraph + 2*x->gl_hidetext, 0);
		canvas_dirty(x, 1);
		if (x->gl_havewindow) {
		    canvas_redraw(x);
		}
		if (x->gl_owner && glist_isvisible(x->gl_owner))
		{
			glist_noselect(x);
		    gobj_vis(&x->gl_gobj, x->gl_owner, 0);
		    gobj_vis(&x->gl_gobj, x->gl_owner, 1);
			canvas_redraw(x->gl_owner);
		}
		//update scrollbars when GOP potentially exceeds window size
		t_canvas *canvas=(t_canvas *)glist_getcanvas(x);

		//if gop is being disabled go one level up
		if (!x->gl_isgraph && x->gl_owner) {
			canvas=canvas->gl_owner;
			canvas_redraw(canvas);
		}

		//if properties window is open, update the properties with the previous window properties		
		t_int properties = gfxstub_haveproperties((void *)x);
		if (properties) {
			sys_vgui(".gfxstub%lx.xrange.entry3 delete 0 end\n", properties);
			sys_vgui(".gfxstub%lx.xrange.entry3 insert 0 %d\n", properties, x->gl_pixwidth);
			sys_vgui(".gfxstub%lx.yrange.entry3 delete 0 end\n", properties);
			sys_vgui(".gfxstub%lx.yrange.entry3 insert 0 %d\n", properties, x->gl_pixheight);
			sys_vgui(".gfxstub%lx.xrange.entry4 delete 0 end\n", properties);
			sys_vgui(".gfxstub%lx.xrange.entry4 insert 0 %d\n", properties, x->gl_xmargin);
			sys_vgui(".gfxstub%lx.yrange.entry4 delete 0 end\n", properties);
			sys_vgui(".gfxstub%lx.yrange.entry4 insert 0 %d\n", properties, x->gl_ymargin);
		}

		sys_vgui("pdtk_canvas_getscroll .x%lx.c\n", (t_int)x);
		sys_vgui("pdtk_canvas_getscroll .x%lx.c\n", (t_int)canvas);
	}

    else if (action == UNDO_FREE)
    {
		//do nothing since undo apply uses a global_buf struct rather than a pointer
    }
}

void canvas_canvas_setundo(t_canvas *x)
{
	canvas_setundo(x, canvas_undo_canvas_apply, canvas_undo_set_canvas(x), "apply");
}

/* --------- 9. create ----------- */

extern t_pd *newest;

typedef struct _undo_create      
{
    int u_index;    			/* index of the created object object */
    t_binbuf *u_objectbuf;      /* the object cleared or typed into */
    t_binbuf *u_reconnectbuf;   /* connections into and out of object */
} t_undo_create;

void *canvas_undo_set_create(t_canvas *x)
{
    t_gobj *y;
    t_linetraverser t;
    t_outconnect *oc;
	int issel1, issel2;

    t_undo_create *buf = (t_undo_create *)getbytes(sizeof(*buf));
    buf->u_index = glist_getindex(x, 0) - 1;
    int nnotsel= glist_selectionindex(x, 0, 0);
	//fprintf(stderr,"buf->u_index=%d nnotsel=%d\n", buf->u_index, nnotsel);

    buf->u_objectbuf = binbuf_new();
	if (x->gl_list) {
		for (y = x->gl_list; y; y = y->g_next)
		{
		    //if (glist_isselected(x, y)) {
			if (!y->g_next) {
				//fprintf(stderr,"undo_set_create: gobj_save\n");
		        gobj_save(y, buf->u_objectbuf);
				break;
			}
		}
		buf->u_reconnectbuf = binbuf_new();
		linetraverser_start(&t, x);
		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);
			issel1 = ( &t.tr_ob->ob_g == y ? 1 : 0);
			issel2 = ( &t.tr_ob2->ob_g == y ? 1 : 0);
			//fprintf(stderr,"undo_set_create linetraverser %d %d\n", issel1, issel2);
			if (issel1 != issel2)
			{
				//fprintf(stderr,"undo_set_create store connection\n");
			    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);
				/*char *text;
				int lengthp;
				binbuf_gettext(buf->u_reconnectbuf, &text, &lengthp);
				fprintf(stderr,"%s\n", text);*/
			}
		}
	}
    return (buf);
}

void canvas_undo_create(t_canvas *x, void *z, int action)
{
    t_undo_create *buf = z;
    t_gobj *y;

	//fprintf(stderr,"canvas = %lx buf->u_index = %d\n", (t_int)x, buf->u_index);

    if (action == UNDO_UNDO)
    {
        glist_noselect(x);
        y = glist_nth(x, buf->u_index);
        glist_select(x, y);
        canvas_doclear(x);
    }
    else if (action == UNDO_REDO)
    {
        pd_bind(&x->gl_pd, gensym("#X"));
   		binbuf_eval(buf->u_objectbuf, 0, 0, 0);
    	pd_unbind(&x->gl_pd, gensym("#X"));
        pd_bind(&x->gl_pd, gensym("#X"));
   		binbuf_eval(buf->u_reconnectbuf, 0, 0, 0);
    	pd_unbind(&x->gl_pd, gensym("#X"));
        if (newest && pd_class(newest) == canvas_class)
        	canvas_loadbang((t_canvas *)newest);
        y = glist_nth(x, buf->u_index);
        glist_select(x, y);
    }
	else if (action == UNDO_FREE) {
		binbuf_free(buf->u_objectbuf);
		binbuf_free(buf->u_reconnectbuf);
        t_freebytes(buf, sizeof(*buf));
	}
}

/* --------- 10. recreate (called from text_setto after text has changed) ----------- */

//recreate uses t_undo_create struct

void *canvas_undo_set_recreate(t_canvas *x, t_gobj *y)
{
    t_linetraverser t;
    t_outconnect *oc;
	int issel1, issel2;

    t_undo_create *buf = (t_undo_create *)getbytes(sizeof(*buf));
    buf->u_index = glist_getindex(x, y);
    int nnotsel= glist_selectionindex(x, 0, 0) - 1; // - 1 is a critical difference from the create
	//fprintf(stderr,"buf->u_index=%d nnotsel=%d\n", buf->u_index, nnotsel);
    buf->u_objectbuf = binbuf_new();
	//y = glist_nth(x, buf->u_index);
	//fprintf(stderr,"undo_set_create: gobj_save\n");
	gobj_save(y, buf->u_objectbuf);

	buf->u_reconnectbuf = binbuf_new();
	linetraverser_start(&t, x);
	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);
		issel1 = ( &t.tr_ob->ob_g == y ? 1 : 0);
		issel2 = ( &t.tr_ob2->ob_g == y ? 1 : 0);
		//fprintf(stderr,"undo_set_create linetraverser %d %d\n", issel1, issel2);
		if (issel1 != issel2)
		{
			//fprintf(stderr,"undo_set_create store connection\n");