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 <math.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);
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 int clipboard_istext = 0;
//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 int paste_xyoffset = 0; /* a counter of pastes to make x,y offsets */
//static void canvas_mouseup_gop(t_canvas *x, t_gobj *g);
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);
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);
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;
// for iemgui objects' wonky click area
//extern void iemgui_getrect_mouse(t_gobj *x, int *xp1, int *yp1,
//    int *xp2, int *yp2);

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

/* 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 */
int connect_exception = 0;

/* 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=20, canvas_last_glist_y=20, 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_text *y)
{
    return (y->te_iemgui);
}

/* ---------------- mathieu 2014.08 --------------------------------- */

void canvas_raise_all_cords (t_canvas *x) {
    /* I think this is deprecated... instead of raising cords, we
       just insert all gobjs (and scalars) before the first patch
       cord.  This way we don't have to constantly raise all the
       patch cords above everything else. */
    //sys_vgui(".x%zx.c raise all_cords\n", x);
}

static void canvas_enteritem (t_canvas *x, int xpos, int ypos, const char *tag) {
    // This will be replaced by GUI-side functionality once we combine
    // object and xlet drawing in a single command from Pd.
    //sys_vgui("pdtk_canvas_enteritem .x%x.c %d %d %s -1\n",
    //    x, xpos, ypos, tag);
}

static void canvas_leaveitem (t_canvas *x) {
    // See comment above
    //sys_vgui("pdtk_canvas_leaveitem .x%x.c\n", x);
}

static void tooltip_erase (t_canvas *x) {
    if (objtooltip) {
        objtooltip = 0;
        canvas_leaveitem(x);
    }
}

// removes highlight from an nlet
static void canvas_nlet_conf (t_canvas *x, int type) {
    int isiemgui = type=='o' ? last_outlet_filter : last_inlet_filter;
    int issignal = type=='o' ? outlet_issignal : inlet_issignal;
    //sys_vgui(".x%x.c itemconfigure %s -stroke %s -fill %s -strokewidth 1\n", x,
    //  type=='o' ? x->gl_editor->canvas_cnct_outlet_tag : x->gl_editor->canvas_cnct_inlet_tag,
    //  (isiemgui ? "$pd_colors(iemgui_nlet)" : 
    //    (issignal ? "$pd_colors(signal_cord)" : "$pd_colors(control_cord)")),
    //    (issignal ? "$pd_colors(signal_nlet)" : "$pd_colors(control_nlet)"));

    /* this is rather confusing, but the canvas_cnct_[xlet]_tag already
       includes the type and index concatenated to the end. */
    gui_vmess("gui_gobj_configure_io", "xsiii",
        x,
        type == 'o' ? x->gl_editor->canvas_cnct_outlet_tag :
            x->gl_editor->canvas_cnct_inlet_tag,
        isiemgui,
        issignal,
        1);
}

void canvas_getscroll (t_canvas *x) {
    //sys_vgui("pdtk_canvas_getscroll .x%zx.c\n",(long)x);
    gui_vmess("gui_canvas_get_overriding_scroll", "x", x);
}

/* ---------------- 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 our parent is a graph, and if that graph itself isn't
        visible, then we aren't either. */
    if (!glist->gl_havewindow && glist->gl_isgraph && glist->gl_owner
        && !gobj_shouldvis(&glist->gl_gobj, glist->gl_owner))
            return (0);
        /* if we're graphing-on-parent and the object falls outside the
        graph rectangle, don't draw it. */
    if (!glist->gl_havewindow && glist->gl_isgraph && glist->gl_goprect &&
        glist->gl_owner && (pd_class(&x->g_pd) != scalar_class) &&
        (pd_class(&x->g_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))
            canvas_raise_all_cords(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 %zx\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);
        }
        /*fprintf(stderr,"checking %d\n", (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))));*/
        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 */
    //fprintf(stderr,"canvas_restore_original_position %zx %zx %s %d\n",
    //    (t_int)x, (t_int)y, objtag, dir);
    int ret = 0;
    // we only do this if we are not embedded inside gop, otherwise
    // when gop is done redrawing we will get properly repositioned
    // by gop's call to restore original position
    if (pd_class(&y->g_pd) != canvas_class || ((t_glist *)y)->gl_owner == x)
    {
        t_object *ob = NULL;
        t_rtext *yrnxt = NULL;

        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 (ret != 1)
        {
            if (dir == -1)
            {
                if (x->gl_list == y)
                {
                    /* we get here if we are supposed to go all the way
                       to the bottom */
                    gui_vmess("gui_lower", "xs",
                        x, objtag ? objtag : "selected");
                }
                else if (yrnxt)
                {
                    /* lower into middle */
                    gui_vmess("gui_find_lowest_and_arrange", "xss",
                        x, rtext_gettag(yrnxt), objtag ? objtag : "selected");
                }
                /*else
                {
                    // fall back to legacy redraw for objects
                    //   that are not patchable
                    canvas_redraw(x);
                    ret = -1;
                }*/
            }
            else
            {
                if (yrnxt)
                {
                    /* raise into middle */
                    gui_vmess("gui_find_lowest_and_arrange", "xss",
                        x, rtext_gettag(yrnxt), objtag ? objtag : "selected");
                }
                else if (y->g_next == NULL)
                {
                    /* we get here if we are supposed to go all the way
                       to the top */
                    gui_vmess("gui_raise", "xs",
                        x, objtag ? objtag : "selected");
                }
                /*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)
    {
        canvas_nlet_conf(x,'i');
        tooltip_erase(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)
    {
        canvas_nlet_conf(x,'o');
        tooltip_erase(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)
{
    char tagbuf[MAXPDSTRING];
    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;
        sprintf(tagbuf, "l%zx", (t_int)oc);
        gui_vmess("gui_canvas_select_line", "xs", x, tagbuf);
        c_selection = x;
        canvas_draw_gop_resize_hooks(x);
    }
}

void glist_deselectline(t_glist *x)
{
    char tagbuf[MAXPDSTRING];
    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);
        canvas_draw_gop_resize_hooks(x);
        sprintf(tagbuf, "l%zx",
            (t_int)x->gl_editor->e_selectline_tag);
        gui_vmess("gui_canvas_deselect_line", "xs", x, tagbuf);
    }    
}

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=%zx x=%zx\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;

        /* Not sure if this is still needed */
        //sys_vgui("pdtk_canvas_update_edit_menu .x%zx 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 *fuddy = 0;
        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");
            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 we have an invalid object even if the text hasn't changed,
        // we should still try to recreate it
        if (!z && fuddy && pd_class(&((t_text *)y)->te_pd) == text_class &&
            ((t_text *)y)->te_type != T_TEXT)
        {
            z = fuddy;
        }

        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);
        /* Not sure if this is still needed */
        //if (!x->gl_editor->e_selection)
        //    sys_vgui("pdtk_canvas_update_edit_menu .x%zx 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);
}

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
        gui_vmess("gui_undo_menu", "xss",
            x, name, "no");
    }
    else if (hadone)
    {
        /* can't figure out what this does... */
        gui_vmess("gui_undo_menu ", "xss",
            "nobody", "no", "no");
    }
}

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

/* ------- 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");
    char tagbuf[MAXPDSTRING];
    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)
        {
            sprintf(tagbuf, "l%zx", (t_int)oc);
            gui_vmess("gui_canvas_delete_line", "xs",
                x, tagbuf);
            // 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 */
            if (pd_class(&t.tr_ob->ob_g.g_pd) == preset_node_class && t.tr_outno == 0)
            {
                //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);