/*   
ZZPrimitiveActions.java
 *    
 *    Copyright (c) 1999-2001, Ted Nelson, Tuomas Lukka and Vesa Parkkinen 
 *
 *    You may use and distribute under the terms of either the GNU Lesser
 *    General Public License, either version 2 of the license or,
 *    at your choice, any later version. Alternatively, you may use and
 *    distribute under the terms of the XPL.
 *
 *    See the LICENSE.lgpl and LICENSE.xpl files for the specific terms of 
 *    the licenses.
 *
 *    This software is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the README
 *    file for more details.
 *
 */
/*
 * Written by Tuomas Lukka
 */
package org.gzigzag;
import java.util.*;
import java.awt.*;

/** A really simple mock script engine. 
 * This class is intended for single, fixed commands that are
 * in reality coded in Java in this file. It is only here so that the Java
 * client can be used standalone.
 * <p>
 * Even worse, it is string-based: it doesn't hassle you about structure,
 * it simply takes the string in the cell and executes a corresponding command.
 * <p>
 * The one nifty thing is the module support: 
 * Given a function name like ZZMbox.FOO
 * it will first dynamically load the class org.gzigzag.module.ZZMbox
 * (this will later be probably xanadu.zz.module), and run its action
 * routine (see ZZModule and ZZMbox docs for details).
 */

public class ZZPrimitiveActions implements ZZExec {
public static final String rcsid = "$Id: ZZPrimitiveActions.java,v 1.141.2.8 2002/03/05 18:21:50 bfallenstein Exp $";
    public static boolean dbg = false;
    static final void p(String s) { if(dbg) ZZLogger.log(s); }
    static final void pa(String s) { ZZLogger.log(s); }
    public ZZPrimitiveActions() {}

    public static java.io.PrintWriter textlog;

    ZZCell findPar(ZZCell view, String param) {
	    ZZCell cur = view.s("d.2", 1);
	    while(cur!=null) {
		    if(cur.getText().equals(param))
			    return cur.s("d.1", 1);
		    cur = cur.s("d.2", 1);
	    }
	    return null;
    }
    int getDimstrAsInt(String param) {
	    if(param.equals("X")) return 0;
	    else if(param.equals("Y")) return 1;
	    else if(param.equals("Z")) return 2;
	    return -1;
    }
    String getDim(ZZCell view, String param) {
	    ZZCell c = findPar(view, param);
	    if(c!=null) 
		return c.getText();
	    int ind=getDimstrAsInt(param); 

	    return ZZDefaultSpace.getDimList(view)[ind];
    }
    String D(ZZCell view, String param) {
	    return getDim(view, param);
    }

    void exchangeCells(ZZCell view1, ZZCell view2) {
	String[] ds1 = ZZDefaultSpace.getDimList(view1);
	String[] ds2 = ZZDefaultSpace.getDimList(view2);
	Hashtable ds = new Hashtable();
	ds.put(ds1[0], ds1[0]);
	ds.put(ds1[1], ds1[1]);
	ds.put(ds2[0], ds2[0]);
	ds.put(ds2[1], ds2[1]);
	ZZCell c1 = ZZCursorReal.get(view1);
	ZZCell c2 = ZZCursorReal.get(view2);
	for(Enumeration e = ds.keys(); 
	    e.hasMoreElements(); ) {
	    String d = (String)e.nextElement();
	    ZZCell n1 = c1.s(d, -1); c1.disconnect(d, -1);
	    ZZCell n2 = c2.s(d, -1); c2.disconnect(d, -1);
	    if(n2 != null) c1.connect(d, -1, n2);
	    if(n1 != null) c2.connect(d, -1, n1);
	    n1 = c1.s(d, 1); c1.disconnect(d, 1);
	    n2 = c2.s(d, 1); c2.disconnect(d, 1);
	    if(n2 != null) c1.connect(d, 1, n2);
	    if(n1 != null) c2.connect(d, 1, n1);
	}
    }

    // Set view cursor
    void svc(ZZCell view, ZZCell to) {
	if(to == null || view == null) return;
	ZZCursorReal.set(view, to);
    }

    ZZCell findOtherView(ZZCell view) {
	ZZCell oth = view.s("d.ctrlview", -1);
	if(oth == null)
	    oth = view.s("d.ctrlview", 1);
	if(oth == null) {
	    System.out.println("CNCTPAIR OTHER NOT FOUND");
	}
	return oth;
    }

    /** Move the cursor.
     * @return Whether a timestamp would be reasonable.
     */
    boolean move(ZZCell view, ZZCell viewCursor, String vdim, int dir,
	    ZZCell realView, ZZCell realCtrl) {
	if ( viewCursor == null ) return false;
	String[] ss = ZZDefaultSpace.getDirActionWaitingAndClear(view);
	if(ss!=null) {
	    String s = ss[0];
	    if(s.equals("CNCTI")) {
		    cnct(view, viewCursor, true, vdim, dir);
	    } else if(s.equals("NEW")) {
		    viewCursor.N(vdim, dir); 
//	    } else if(s.equals("NEWANDEDIT")) {
//		    svc(view, viewCursor.N(vdim, dir)); 
//		    switchcursmode(view);
//			XXX Problem: this doesn't switch keybindings mode
	    } else if(s.equals("EXCISE")) {
		    viewCursor.excise(vdim);
	    } else if(s.equals("DISC")) {
		    viewCursor.disconnect(vdim, dir); 
	    } else if(s.equals("HOP")) {
		    viewCursor.hop(vdim, dir); 
	    } else if(s.equals("CLONE")) {
		    ZZCell clone = ZZCursorReal.get(realView).zzclone();
		    viewCursor.insert(vdim, dir, clone);
	    } else if(s.equals("CLONECTRL")) {
		    ZZCell clone = ZZCursorReal.get(realCtrl).zzclone();
		    viewCursor.insert(vdim, dir, clone);
	    } else if(s.equals("CNCTPAIR")) {
		    smartconnect(viewCursor, vdim, dir, ZZCursorReal.get(
					findOtherView(view)));
	    } else if(s.equals("CNCTC")) {
		    cnctcln(view, viewCursor, true, vdim, dir);
	    } else if(s.equals("CNCT")) {
		    cnct(view, viewCursor, false, vdim, dir);
	    } else if(s.equals("SORTALPH")) {
		    ZZUtil.sortRank(viewCursor, vdim, dir, 
			new ZZUtil.Comparator() {
			    public int compare(ZZCell c1, ZZCell c2) {
				return c1.getText().compareTo(c2.getText());
			    }
			}, true);
	    } else if(s.equals("END")) {
		    svc(view, viewCursor.h(vdim, dir));
	    } else if(s.equals("MONOCHUG")) {
		if(ss[1] == null || ss[1].equals("")) {
		    p("Move: "+s+" "+vdim+" "+dir);
		    ZZDefaultSpace.storeDirActionWaiting(view, s);
		    ZZDefaultSpace.storeDirWaiting(view, vdim, dir);
		    return false;
		}
		// monochug operation
		int ddir = (ss[2].equals("+") ? 1 : -1);
		String ddim = ss[1];
		ZZCell targ = viewCursor.s(ddim, ddir);
		if(targ == null) return false;
		targ = targ.s(vdim, dir);
		if(targ == null) return false;
		if(targ.s(ddim, -ddir) != null)
		    return false;
		viewCursor.disconnect(ddim, ddir);
		viewCursor.connect(ddim, ddir, targ);
	    } else if(s.equals("FINDTEXT")) {
		String tf = ZZDefaultSpace.getInbuf(view.getSpace(), false);
		if(tf == null || tf.equals("")) return false;
		for(ZZCell c = viewCursor.s(vdim, dir);
		    c != null && c != viewCursor;
		    c = c.s(vdim, dir)) {
		    if(c.getText().indexOf(tf) >= 0) {
			svc(view, c);
			return true;
		    }
		}
	    }
	    return true;
	} else {
	    String s = ZZDefaultSpace.getInbuf(view.getSpace(), true);
	    /*
	     * * DO NOT DO IT. TOO CONFUSING FOR USERS.
	    if(s != null && !s.equals("")) {
		ZZCell c = view.getSpace().getCellByID(s);
		if(c == null) {
		    throw new ZZError("No such cell: '"+s+"'...");
		}
		smartconnect(viewCursor, vdim, dir, c);
	    }
	    */
	    svc(view, viewCursor.s(vdim, dir));
	    // Do timestamp: it's a motion.
	    return true;
	}
    }
    
// or only mark, if ...
    void mrkmv(ZZCell v, ZZCell vc, String dim, int dir) {
	    // New way: in the view
	    synchronized(v.getSpace()) {
		    ZZCell m = v.s("d.mark", 1);
		    boolean had = false;
		    ZZCell m0 = v;
		    while(m!=null) {
			    if(m.h("d.mark-set",-1)
				==vc) { had = true; break; }
			    m0 = m;
			    m = m.s("d.mark", 1);
		    }
		    if(had) {
			    // Delete the whole relation cell.
			    // The ranks collapse around it just right.
			    m.delete(); 
		    } else {
			    ZZCell mark = vc.N("d.mark-set", 1);
			    m0.connect("d.mark", mark);
		    }
	    }
	    if(dim != null && dir != 0)
		move(v, vc, dim, dir, null, null);
    }

    // XXX Combine the following two.
    // Connect
    void cnct(ZZCell v, ZZCell vc, boolean inclCurs, String dim, int dir) {
	// Also clears mark.
	ZZCell[] cs;
	synchronized(v.getSpace()) {
	    cs = ZZDefaultSpace.getMark(v);
	    ZZDefaultSpace.clearMark(v);
	    ZZCell cur = (inclCurs ? vc : null);
	    for(int i=0; i<cs.length; i++) {
		if(cur != null)
		    cur.connect(dim, dir, cs[i]);
		cur = cs[i];
	    }
	}
    }

    // Clone, then connect
    void cnctcln(ZZCell v, ZZCell vc, boolean inclCurs, String dim, int dir) {
	// Also clears mark.
	ZZCell[] cs;
	synchronized(v.getSpace()) {
	    cs = ZZDefaultSpace.getMark(v);
	    ZZDefaultSpace.clearMark(v);
	    ZZCell cur = (inclCurs ? vc : null);
	    for(int i=0; i<cs.length; i++) {
		ZZCell to = cs[i].h("d.clone",1).N("d.clone",1);
		if(cur != null)
		    cur.connect(dim, dir, to);
		cur = to;
	    }
	}
    }

    // Rotate a dimension
    void chugdim(ZZCell v, String dx, int dir) {
    synchronized(v.getSpace()) {
	    int nth=getDimstrAsInt(dx);
	    ZZCell cur = v.s("d.dims", nth+1);
	    ZZCell cd = ZZCursorReal.get(cur);
	    cd = cd.s(ZZDefaultSpace.dimListDimen, dir);
	    if(cd != null) 
		ZZCursorReal.set(cur, cd);
    }
    }

    // Rotate a dimension
    void setdim(ZZCell v, String dx, ZZCell dimc) {
    synchronized(v.getSpace()) {
	    int nth=getDimstrAsInt(dx);
	    ZZCell cur = v.s("d.dims", nth+1);
	    ZZCursorReal.set(cur, dimc);
    }
    }


    // Severs connections to other dimensions / cursors. Good??
    void setdims(ZZCell v, ZZCell s) {
	    while(true) {
		    v = v.s("d.dims", 1);
		    if(v==null) break;
		    // s.insert("d.dim", -1, v);
		    ZZDefaultSpace.setDimFromCell_sever(v, s);
		    ZZCell sn = s.s("d.2", 1);
		    if(sn!=null) s = sn;
	    }
    }

    void hopraster(ZZCell v, int dir) {
	pa("HOPRASTER "+dir);

	ZZCell rc = ZZDefaultSpace.findInheritableParam(v, "View");
	if(rc != null) {
	    ZZCell r = ZZCursorReal.get(rc);
	    r = r.s("d.2", dir);
	    if(r!=null)
		ZZCursorReal.set(rc, r); 
	}
    }

    void hopffactory(ZZCell v, int dir) {
	pa("HOPFFACT "+dir);
	ZZCell rc = ZZDefaultSpace.findInheritableParam(v, "CellView");
	if(rc != null) {
	    ZZCell r = ZZCursorReal.get(rc);
	    r = r.s("d.2", dir);
	    if(r!=null)
		ZZCursorReal.set(rc, r); 
	}
    }

    void clonelink(ZZCell from, String dim, ZZCell[] toclone) {
	    ZZCell cur = from;
	    for(int i=0; i<toclone.length; i++) {
		    ZZCell n = toclone[i].N("d.clone", 1);
		    cur.connect(dim, n);
		    cur = n;
	    }
    }

    void do_goto(ZZCell view) {
	String s = ZZDefaultSpace.getInbuf(view.getSpace(), true);
	// WouldBreak if inbuf is empty, so we don't go there 
	if( s == null || s.equals(""))
	    return;
	ZZCell c = view.getSpace().getCellByID(s);
	if(c == null) {
	    throw new ZZError("No such cell: '"+s+"'...");
	}
	ZZCursorReal.set(view, c);
    }

    // CURSEL: Cursor selection
    // SELEVATE: Cursel along d.cursor-list instead of SysCursors list
    void cursel(ZZCell view, int dir, boolean selevate) {
        ZZCell cur = view.h("d.cursor-cargo", -1);
	ZZCell curcln = cur.s("d.clone", 1);
        ZZCell c;
        if(selevate) {
            c = cur.s("d.cursor-list", dir);
            if(c == null)
                return;
        } else {   // XXX check for "kind" of cursor (active, personalized)
	    ZZCell cln = curcln;
	    LoopDetector l = new LoopDetector();
	    while(true) {
		cln = cln.s("d.2", dir);
		l.detect(cln);
	        if(cln == null) return;
		c = cln.h("d.clone", -1);
	        if(c != null && (c.s("d.cursor-list", -1) != null
		                 || c.s("d.cursor", -1) != null))
		    break;
	    };
	}
        
        ZZCursorReal.attach(view, c);
    }

    public void smartconnect(ZZCell c1, String dim, int dir, ZZCell c2) {
	if(c1.s(dim, dir) != null) {
	    // If has a neighbour and c2 unconnected, insert
	    if(c2.s(dim, -1) == null &&
	       c2.s(dim, 1) == null) {
		c1.insert(dim, dir, c2);
	    }
	    System.out.println("Can't connect: conflicting connections exist");
	    return;
	}
	c1.connect(dim, dir, c2);
    }

    public void switchcursmode(ZZCell view) {
	ZZCursorReal.setOffs(view, 0);
    }
    public void switchcursmodeoff(ZZCell view) {
	ZZCursorReal.setOffs(view, ZZCursorReal.NO_OFFSET);
    }

    // XXX should this throw a ZZError?
    public void callbackFailed(String c, String s) {
	System.out.println("'"+c+"' failed: "+s);
    }
    
    public void execCallback(ZZCell code, 
			     ZZCell target, 
			     ZZView zzdv, ZZView zzcv, 
			     String key,
			     Point pt, 
			     ZZScene xi)
    {
	ZZCell dataView = zzdv.getViewcell();
	ZZCell dataCursor = ZZCursorReal.get(dataView);
	ZZCell ctrlView = (zzcv==null ? null : zzcv.getViewcell());
	ZZCell ctrlCursor = (zzcv==null ? null : ZZCursorReal.get(ctrlView));
	ZZCell view, viewCursor;
	ZZCell otherView;
	ZZView zzv;

	p("EXCB " + code + " "+code.getSpace());
	p("PAR: "+zzdv+" "+zzcv);
	int ind;
	// ZZCell target = clicked;
	// if(target==null)
	//     target = viewCursor;
	synchronized(code.getSpace()) {
	    boolean fastany = true;
	    /** The default is to clear the 
	     * action cells after any action. Setting this
	     * flag causes that not to happen. Useful when you want
	     * to wait for the next command after a command.
	     */
	    boolean dontClearAction = false;
	    boolean dontStamp = false;
	    String c = code.getText();
	    p("CODE: '"+c+"'");
	    // pa("CODE: '"+c+"'");

            if((ind = c.indexOf("."))!=-1) {
		// A module call. 
		// Load the module and call the action
		// routine.
		ZZModule m = ZZModule.getModule(c.substring(0, ind));
		if(m!=null)
		    m.action(c.substring(ind+1),
				code, target,
				zzdv, zzcv, 
				key, pt, xi);
		else
		    callbackFailed(c, "MODULE NOT FOUND");

		return;

		// XXX Stamp?
	    }

	    StringTokenizer st = new StringTokenizer(c);
	    String[] toks = new String[st.countTokens()];
	    for(int i=0; i<toks.length; i++)
		    toks[i] = st.nextToken();

	    String dx = null;
	    String vdim = null;
	    int dir = 0;
	    int sndedge = -1;

	    if (toks.length == 0) {
                    return;
	    }
	
	    // Converting the deprecated tokens with explicite view
	    // XXX should be removed at some point; default usec to false then
	    boolean usec = true;  // "use control view?"
	    if(toks[0].equals("CTRL"))
		toks[0] = "CURS";
	    else if(toks[0].equals("SETCDIMS"))
		toks[0] = "SETDIMS";
	    else if(toks[0].equals("CDIM"))
		toks[0] = "DIM";
	    else if(toks[0].equals("CRASTER"))
		toks[0] = "RASTER";
	    else if(toks[0].equals("CTRLGOTO"))
		toks[0] = "GOTO";
	    else if(toks[0].equals("CFETCH"))
	        toks[0] = "FETCH";
	    else
		usec = false;
		
	    if(toks.length > 1) {
		    if(toks[1].equals("CTRL")) { usec=true; }
			
		    if(toks[1].equals("+")) { dx=null; dir = 1; }
		    if(toks[1].equals("-")) { dx=null; dir = -1; }

		    if(toks[1].equals("C+")) { dx=null; dir = 1;  usec=true; }
		    if(toks[1].equals("C-")) { dx=null; dir = -1; usec=true; }

		    if(toks[1].equals("X+")) { dx="X"; dir = 1; }
		    if(toks[1].equals("X-")) { dx="X"; dir = -1; }
		    if(toks[1].equals("Y+")) { dx="Y"; dir = 1; }
		    if(toks[1].equals("Y-")) { dx="Y"; dir = -1; }
		    if(toks[1].equals("Z+")) { dx="Z"; dir = 1; }
		    if(toks[1].equals("Z-")) { dx="Z"; dir = -1; }

		    if(toks[1].equals("X")) { dx="X"; dir = 0; }
		    if(toks[1].equals("Y")) { dx="Y"; dir = 0; }
		    if(toks[1].equals("Z")) { dx="Z"; dir = 0; }

		    if(toks[1].equals("CX+")) { dx="X"; dir = 1;  usec=true; }
		    if(toks[1].equals("CX-")) { dx="X"; dir = -1; usec=true; }
		    if(toks[1].equals("CY+")) { dx="Y"; dir = 1;  usec=true; }
		    if(toks[1].equals("CY-")) { dx="Y"; dir = -1; usec=true; }
		    if(toks[1].equals("CZ+")) { dx="Z"; dir = 1;  usec=true; }
		    if(toks[1].equals("CZ-")) { dx="Z"; dir = -1; usec=true; }

		    if(toks[1].equals("T0+")) { sndedge = 0; dir = 1; }
		    if(toks[1].equals("T0-")) { sndedge = 0; dir = -1; }
		    if(toks[1].equals("T1+")) { sndedge = 1; dir = 1; }
		    if(toks[1].equals("T1-")) { sndedge = 1; dir = -1; }
	    }

	    if(usec && ctrlView == null) {
		callbackFailed(c, "NO CONTROL VIEW");
		ZZDefaultSpace.getDirActionWaitingAndClear(dataView);
		// Do not timestamp taking the operation out, either,
		// because putting it in was not stamped.
		// XXX Some strange bug?
		code.getSpace().stamp();
		return;
	    }

	    if(!usec) {
		view = dataView;
		otherView = ctrlView;
		viewCursor = dataCursor;
		zzv = zzdv;
	    } else {
		view = ctrlView;
		otherView = dataView;
		viewCursor = ctrlCursor;
		zzv = zzcv;
	    }
	
	    if(dx != null)
		vdim = D(view, dx);
	    if(target != null)
		viewCursor = target;

	    ZZCell coderoot = code.getRootclone();
	    if(coderoot.s("d.xeq") != null) {
                org.gzigzag.flowing.FlowingClang.run
		    (coderoot, new Data(ctrlView, dataView, key), false);
	    } else if(toks[0].equals("NEW") ||
		    toks[0].equals("NEWANDEDIT") ||
		    toks[0].equals("EXCISE") ||
		    toks[0].equals("DISC") ||
		    toks[0].equals("CNCTI") ||
		    toks[0].equals("CNCTPAIR") ||
		    toks[0].equals("CLONE") ||
		    toks[0].equals("CLONECTRL") ||
		    toks[0].equals("CNCT") ||
		    toks[0].equals("CNCTC") ||
		    toks[0].equals("HOP") ||
		    toks[0].equals("MONOCHUG") ||
		    toks[0].equals("SORTALPH") ||
		    toks[0].equals("FINDTEXT") ||
		    toks[0].equals("END")) {

		// XXX Should this be implemented differently, so that the
		//     dir doesn't need to be stored in the structure?
		ZZDefaultSpace.storeDirActionWaiting(view, toks[0]);
		dontClearAction = true;
		if (dx != null) {
		    move(view, viewCursor, vdim, dir, dataView, ctrlView);
		    // Move has commands that take more than one dir.
		} else {
		    dontStamp = true;
		}
	    } else if(toks[0].equals("CRSR")) {
		dontStamp = 
		   ! move(view, viewCursor, vdim, dir, dataView, ctrlView);
		// Move has commands that take more than one dir.
		dontClearAction = true;
	    } else if(toks[0].equals("EXCHANGECELLS")) {
		exchangeCells(dataView, ctrlView);
	    } else if(toks[0].equals("ORIGINAL")) {
		svc(view, viewCursor.h("d.clone", -1));
	    } else if(toks[0].equals("NEXTCLONE")) {
		ZZCell foo = viewCursor.s("d.clone", 1);
		if(foo != null) svc(view, foo);
	    } else if(toks[0].indexOf("MOUSE") == 0) {
		Object ob = xi.getObjectAt(pt.x, pt.y);
		ZZCursor cc=null;
		ZZCell cell=null;

		if(ob instanceof ZZCursor) {
		    cc = (ZZCursor)ob;
		    cell=cc.get();
		} else if(ob instanceof ZZCell) {
		    cell=(ZZCell)ob;
		} else return;
		if(cell==null) return;

		if(toks[0].equals("MOUSESETC")) {
		    svc(view, cell);
		    fastany = false;
		}
		else if(toks[0].equals("MOUSESETCTXT")) {
		    if(cc==null) return;
		    svc(view, cell);
		    ZZCursorReal.setOffs(view, cc.getOffs());
		    fastany = false;
		}
		else if(ctrlCursor!=null && c.equals("MOUSEEXEC")) {
		    pa("MOUSEEXEC");
		    this.execCallback(ctrlCursor, cell,
				      zzv, zzcv, null, null, null);
		       
		}
		else if(toks[0].equals("MOUSEMARK")) {
		    mrkmv(view, cell, null, 0);
		    fastany = false;
		} else if(toks[0].equals("MOUSESETDIMOTHER")) {
		    setdim(otherView, dx, cell);
		} else {
		    callbackFailed(c, "Unknown MOUSE code");
		    return;
		}
	    }
	    else if(ctrlCursor!=null && c.equals("EXEC")) {
	    // This is an interesting one: it just means "execute 
	    // whatever cell is visible in the control view.
	    // So we call ourselves...
	    // XXX inherit xi really?
	        ZZCommand comm = ZZCommand.getCommand(ctrlCursor);
	        if(comm != null)
		    comm.execCallback(viewCursor,
			zzdv, zzcv, null, pt, xi);
		else
		    this.execCallback(ctrlCursor, viewCursor,
			zzdv, zzcv, null, pt, xi);
	    }
	    else if(c.equals("HERA1")) {
		// Execute the first, primitive calling sequence of
		// a Heraclitus Clang primitive poswards on d.2 from
		// the command cell
		ZZCell hc = code.s("d.2", 1);
		if(hc == null) throw new ZZError("No heraclitus1 prim!");
		ZZCell curspar = code.N();
		ZZCell curs1 = code.N();
		ZZCell curs2 = curs1.N("d.1", 1);
		ZZCursorReal.set(curs1, ctrlView);
		ZZCursorReal.set(curs2, dataView);
		ZZCursorReal.set(curspar, curs1);
		try {
		    p("Enter heraclitus: ");
		    org.gzigzag.heraclitus.HeraclitusClang.execute(
			hc, curspar);
		    p("Exit heraclitus");
		} finally {
		    ZZCursorReal.delete(curs1);
		    ZZCursorReal.delete(curs2);
		    ZZCursorReal.delete(curspar);
		    curs1.delete();
		    curs2.delete();
		    curspar.delete();
		}
	    }

	    else if(toks[0].equals("MARK"))
		    mrkmv(view, viewCursor, dx, dir);
	    else if(toks[0].equals("DIM"))
		    chugdim(view, dx, dir);
	    else if(toks[0].equals("SETDIMS"))
		    setdims(view, viewCursor);
	    else if(toks[0].equals("RASTER"))
		    hopraster(view, dir!=0 ? dir : 1);
	    else if(toks[0].equals("FFACTORY"))
		    hopffactory(view, dir!=0 ? dir : 1);
	    else if(toks[0].equals("HOME")) {
		    ZZCell home = view.getSpace().getHomeCell();
		    svc(view, home);
	    }
	    else if(toks[0].equals("HOMECLR")) {
		    ZZCell home = view.getSpace().getHomeCell();
		    ZZCell datarec = ZZDefaultSpace
			.findInheritableParam(dataView, "CursorRecovery");
		    if(datarec!=null) ZZCursorReal.attach(dataView, datarec);
		    ZZCell ctrlrec = ZZDefaultSpace
			.findInheritableParam(ctrlView, "CursorRecovery");
		    if(ctrlrec!=null) ZZCursorReal.attach(ctrlView, ctrlrec);
		    svc(dataView, home);
		    svc(ctrlView, home);
		    ZZCell dimlist =
			    ZZDefaultSpace.findDefaultDimlist(home);
		    setdims(dataView, dimlist);
		    setdims(ctrlView, dimlist);

		    ZZDefaultSpace.clearMark(dataView);

	    } else if(toks[0].equals("DELETESCRAM")) {
		    ZZCell mv = null;
		    mv = viewCursor.s(D(view, "X"), -1);
		    if(mv == null) 
			mv = viewCursor.s(D(view, "X"), +1);
		    if(mv == null) 
			mv = viewCursor.s(D(view, "Y"), -1);
		    if(mv == null) 
			mv = viewCursor.s(D(view, "Y"), +1);
		    if(mv == null) 
			mv = viewCursor.s(D(view, "Z"), -1);
		    if(mv == null) 
			mv = viewCursor.s(D(view, "Z"), +1);
		    if(mv == null) 
			mv = view.getSpace().getHomeCell();
		    svc(view, mv);
		    viewCursor.delete();
	    }

	    else if(toks[0].equals("QUIT")) {
		// Commit changes to space here 
		viewCursor.getSpace().commit();
		SafeExit.exit(0);
	    }
	    else if(toks[0].equals("APPENDINPUT")) {
		if(key != null && key.length() == 1)
		    ZZDefaultSpace.appendInbuf(viewCursor.getSpace(), key);
		dontStamp = true;
	    } else if(toks[0].equals("BACKSPACEINPUT")) {
		ZZDefaultSpace.appendInbuf(viewCursor.getSpace(), null);
		dontStamp = true;
	    } else if(toks[0].equals("CLRINPUT")) {
		ZZDefaultSpace.getInbuf(viewCursor.getSpace(), true);
		dontStamp = true;
	    } else if(toks[0].equals("GOTO"))
		do_goto(view);

	    // Sound span adjustment. These will be useful
	    // in a more general way later on.
	    else if(toks[0].equals("SNDL")) {
	        Span sp = viewCursor.getSpan();
		ZZCell n = viewCursor.s("d.2", sndedge*2-1);
	        Span nsp = n.getSpan();
		if(sp!=null && nsp!=null) {
		        Span[] sps;
			if(sndedge==0) {
			    sps = nsp.adjustEdgeLocked(100000000*dir, sp, 500000000);
			    n.setSpan(sps[0]);
			    viewCursor.setSpan(sps[1]);
			} else {
			    sps = sp.adjustEdgeLocked(100000000*dir, nsp, 500000000);
			    viewCursor.setSpan(sps[0]);
			    n.setSpan(sps[1]);
			}
		} else if(sp!=null)
		    	viewCursor.setSpan(
				sp.adjustEdge(sndedge, 100000000 * dir));
	    } else if(toks[0].equals("SNDS")) {
	        Span sp = viewCursor.getSpan();

		if(sp!=null)
		    	viewCursor.setSpan(
				sp.adjustEdge(sndedge, 100000000 * dir));
	    } else if(toks[0].equals("SNDSPLIT")) {
		ZZCell n = viewCursor.N("d.2", 1);
	        Span sp = viewCursor.getSpan();
		if(sp!=null) {
		    Span[] sps = sp.splitInHalf();
		    viewCursor.setSpan(sps[0]);
		    n.setSpan(sps[1]);
		}
	    } else if(toks[0].equals("SNDJOIN+")) {
		ZZCell o = viewCursor.s("d.2", 1);
		if(o!=null) {
		    Span sp1 = viewCursor.getSpan();
		    Span sp2 = o.getSpan();
		    if(sp1!=null && sp2!=null) {
			Span spj = sp1.join(sp2, 500000000);
			if(spj!=null) {
				viewCursor.setSpan(spj);
				// XXX ??? Try to absorb links?
				o.delete();
			}
		    }
		}
	    } else if(toks[0].equals("SWAPCRSR")) {
		ZZCell view2 = findOtherView(view);
		ZZCell view2c = ZZCursorReal.get(view2);
		svc(view, view2c);
		svc(view2, viewCursor);
	    } else if(toks[0].equals("FETCH")) {
		svc(findOtherView(view), viewCursor);
	    } else if(toks[0].equals("PUICOPY")) {
		ZZUtil.puiCopy(viewCursor);
	    } else if(toks[0].equals("PUIPASTE")) {
		ZZUtil.puiPaste(viewCursor);
	    } else if(toks[0].equals("PUICOPYLINE")) { // Copy along y-dim
		ZZUtil.puiCopy(viewCursor, ZZCursorReal.get(
					    dataView.s("d.dims", 1)
						    .s("d.dims", 1)
					   ).getText());
            } else if(toks[0].equals("PUICOPYRANK")) { // Copy along y-dim
		                                       // insert \n between
                                                       // cells
                ZZUtil.puiCopyRank(viewCursor, ZZCursorReal.get(
                                            dataView.s("d.dims", 1)
                                                    .s("d.dims", 1)
                                           ).getText());
	    } else if(toks[0].equals("TXTINSERT")) {
		// XXX ???
		p("Txtins: '"+key+"'");
		CharScroll cs = (CharScroll)
		    Scroll.obtain(viewCursor.getSpace(), 
			    "textinput");
		long offs = cs.curEnd();
		cs.append(key);
		long offs2 = cs.curEnd()-1;
		VStream.insert(new ZZCursorReal(view), 
		    Span.create(
			Address.scrollOffs(cs, offs),
			Address.scrollOffs(cs, offs2)
		    )
		);
	    } else if(toks[0].equals("SWITCHCURSMODE")) {
		switchcursmode(view);
		dontStamp = true;
	    } else if(toks[0].equals("SWITCHOFFCURSMODE")) {
		switchcursmodeoff(view);
            } else if(toks[0].equals("CTXTHOME")) {
                if (ZZCursorReal.getOffs(view) == ZZCursorReal.NO_OFFSET) return;
                ZZCursorReal.setOffs(view, 0);
                dontStamp = true;
            } else if(toks[0].equals("CTXTEND")) {
                if (ZZCursorReal.getOffs(view) == ZZCursorReal.NO_OFFSET) return;
                ZZCursorReal.setOffs(view, viewCursor.getText().length());
                dontStamp = true;                                                           } else if(toks[0].equals("CTXTSOL")) {  // SOL = start of line
                if (ZZCursorReal.getOffs(view) == ZZCursorReal.NO_OFFSET) return;
                int cur = ZZCursorReal.getOffs(view);
                String line = viewCursor.getText();
                if (cur >= line.length()) cur = line.length()-1;
                if (line.charAt(cur) == '\n') --cur;
                for (int i = cur; i  >= 0; --i) {
                    p("seeking SOL: charAt = " + line.charAt(i));
                    if (line.charAt(i) == '\n') {
                        cur = i+1;
                        break;
                    }
                    if (i == 0) {
                        cur = i;
                        break;
                    }
                }
                if (cur > line.length()) cur = line.length();
                if (cur < 0) cur = 0;
                ZZCursorReal.setOffs(view, cur);
                dontStamp = true;                                   
            } else if(toks[0].equals("CTXTEOL")) {  // EOL = start of line
                if (ZZCursorReal.getOffs(view) == ZZCursorReal.NO_OFFSET) return;
                int cur = ZZCursorReal.getOffs(view);
                String line = viewCursor.getText();
                for (int i = cur; i < line.length(); ++i) {
                    if (line.charAt(i) == '\n') {
                        cur = i;
                        break;
                    }
                    if (i == line.length() - 1) {
                        cur = line.length();
                        break;
                    }
                }
                if (cur > line.length()) cur = line.length();
                if (cur < 0) cur = 0;
                ZZCursorReal.setOffs(view, cur);
                dontStamp = true;                                  
	    } else if(toks[0].equals("CTXTCRSR")) {
		int cur = ZZCursorReal.getOffs(view);
		if(cur == ZZCursorReal.NO_OFFSET) return;
		cur += dir;
		if(cur < 0) cur = 0;
		if(cur > viewCursor.getText().length())
		    cur = viewCursor.getText().length();
		ZZCursorReal.setOffs(view, cur);
		dontStamp = true;
	    } else if(toks[0].equals("VSTRMCRSR")) {
		if(ZZCursorReal.getOffs(view) == ZZCursorReal.NO_OFFSET) 
		    throw new ZZError("Need cursor offset");

		if(!Stream.move(
			    new ZZCursorReal(view),
			    VStream.dim,
			    dir)) {
		    callbackFailed("VSTRMCRSR", "nothing there");
		} else {
		    fastany = false;
		}
	
		dontStamp = true;
	    } else if(toks[0].equals("VSTRMJUMP")) {
		int offs = ZZCursorReal.getOffs(view);
		String txt = viewCursor.getText();
		ZZCell next = viewCursor.s("d.2", dir!=0 ? dir : 1);
		
		offs = dir >= 0 ? txt.indexOf(' ', offs)
		                : txt.lastIndexOf(' ', offs - 1);
		if(offs > -1)
		    ZZCursorReal.setOffs(view, offs + (dir<0 ? 0 : 1));
		else if(next != null) {
		    svc(view, next);
		    ZZCursorReal.setOffs(view,
				         dir<0 ? next.getText().length() : 0);
		} else
		    ZZCursorReal.setOffs(view, dir<0 ? 0 : txt.length() - 1);
		dontStamp = true;
	    } else if(toks[0].equals("VSTRMSPLIT")) {
		ZZCell next = viewCursor.N("d.2", dir!=0 ? dir : 1);
		if(viewCursor.getSpan() == null) {
		    int offs = ZZCursorReal.getOffs(view);
		    String txt = viewCursor.getText();
		    String one = txt.substring(0, offs),
		           two = txt.substring(offs);
		    if(dir >= 0) {
		        viewCursor.setText(one); next.setText(two);
		    } else {
			viewCursor.setText(two); next.setText(one);
		    }
		}  // XXX Split spans, too
		ZZCursorReal.setOffs(view, 0);
		svc(view, next);
		dontStamp = true;
	    } else if(toks[0].equals("CTXTINSERT") ||
		      toks[0].equals("CTXTBKSP") ||
		      toks[0].equals("CTXTDEL")) {
		dontStamp = true;
		if(viewCursor.getSpan() != null) {
		    System.out.println("Can't modify span");
		    return;
		}
		int cur = ZZCursorReal.getOffs(view);
		// Make sure it fits.
		if(cur > viewCursor.getText().length())
		    cur = viewCursor.getText().length();
		if(cur == ZZCursorReal.NO_OFFSET) return;
		StringBuffer s = new StringBuffer(viewCursor.getText());
               if(toks[0].equals("CTXTINSERT"))  {
                    p("CTXTINSERT: key = " + key);
                    String ik = key;
                    if (ik != null && ik.equals("Enter")) ik = "\n";
                    // Don't insert e.g. "Shift"
                    if(ik != null && ik.length() == 1) {
                        if(textlog != null) {
                            textlog.print(ik);
                            // flush all the time so nothing is lost
                            // in a crash
                            textlog.flush();
                        }
                        s.insert(cur, ik);
                        cur += 1;
                    }                                                 
		} else if(toks[0].equals("CTXTBKSP")) {
		    if(cur > 0) {
			String str = s.toString();
			// XXX delete requires JDK 1.2
			s = new StringBuffer( str.substring(0, cur-1) );
			s.append(str.substring(cur));

			cur -= 1;
		    }
		} else if(toks[0].equals("CTXTDEL")) {
		    if(cur < viewCursor.getText().length()) {
		    	String str = s.toString();
			s = new StringBuffer( str.substring(0, cur) );
			s.append(str.substring(cur+1));
		    }
		}
		viewCursor.setText(s.toString());
		ZZCursorReal.setOffs(view, cur);
            } else if(toks[0].equals("CURSEL"))
                cursel(view, dir, false);
            else if(toks[0].equals("SELEVATE"))
                cursel(view, dir, true);
	    else if(toks[0].equals("CreateCursors")) {
		ZZCell h = view.getSpace().getHomeCell();
		ZZCell sc = ZZDefaultSpace
		    .findOnSystemlist(view.getSpace(), "SysCursors", false);
		if(sc != null) {
		    ZZDefaultSpace.newSysCursor(sc, h, Color.blue.brighter());
		    ZZDefaultSpace.newSysCursor(sc, h, Color.yellow.darker());
		    ZZDefaultSpace.newSysCursor(sc, h, Color.red.darker());
		    ZZDefaultSpace.newSysCursor(sc, h, new Color(180, 0, 255));
		} else
		    callbackFailed(c, "SysCursors list required");
            } else if(toks[0].equals("NEWVIEWS")) {
		// Create a new view pair.
		ZZDefaultSpace.newViewPair(view.getSpace());
            } else if(toks[0].equals("EDITVIEW") || toks[0].equals("HELP")) {
		boolean help = toks[0].equals("HELP");
                ZZCell home = dataView.getSpace().getHomeCell();
                ZZCell rl = home.findText("d.2", 1, "AllViews"); 
                rl = rl.s("d.1", 1);
                rl = rl.findText("d.2", 1, "Edit");
                if (rl == null) throw new ZZError("Edit view not found");
                rl = rl.getOrNewCell("d.clone", 1);
		ZZCell cursCell;
		if(help) {
		    cursCell = home.N();
		    ZZCursorReal.set(cursCell, 
				     viewCursor.getOrNewCell("d.help", 1));
		} else
		    cursCell = dataView;
		
		ZZCell win = ZZDefaultSpace.newToplevelView(dataView.getSpace(),
			help ? "Help" : "Edit",
			help ? 100 : 512, help ? 100 : 449, 
			help ? 400 : 512, help ? 400 : 100,
			rl, null, // XXX Defaultbind?
			null, cursCell,
			null,
			Color.white); // XXX PREFERENCE!!!
	    } else if(toks[0].equals("EDITHACK")) {
		new ZZTextView(view);
	    } else if(toks[0].equals("APPLITUDE")) {
		ApplitudeMgr.rotateWindowApp(view, dir);
            } else if(toks[0].equals("GETSPACEID")) {
                target.setText(target.getSpace().getID());
            } else if(toks[0].equals("SETSPACEID")) {
                target.getSpace().setID(target.getText());
	    } else if(toks[0].equals("UPDATEWINS")) {
		ZZWindows.update();
	    } else if(toks[0].equals("ACCURSE")) {
		// Make the cell accursed in the other window a cursor to the
		// cell accursed in window for which the action occured.
		ZZCursorReal.set(ZZCursorReal.get(otherView), viewCursor);
	    } else if(toks[0].equals("UNDO")) {
		code.getSpace().undo();
		dontStamp = true;
	    } else if(toks[0].equals("REDO")) {
		code.getSpace().redo();
		dontStamp = true;
	    } else if(toks[0].equals("COMMIT")) {
		code.getSpace().commit();
	    }
	    else
		callbackFailed(c, "UNKNOWN CODE");

	    p("ZZPrimitiveActions: postlude: "+fastany+" "+zzv+" "+
		dontClearAction);

	    if(fastany)
		ZZUpdateManager.setFast(zzv);

	    // Clear the waiting dir action
	    if(!dontClearAction)
		ZZDefaultSpace.getDirActionWaitingAndClear(view);

	    if(!dontStamp) 
		code.getSpace().stamp();
	}
    }

    static ZZCell addAct(ZZCell s, String name, String act) {
	    ZZCell n1 = s.N("d.2", 1);
	    n1.setText(name);
	    ZZCell n2 = n1.N("d.1", 1);
	    n2.setText(act);
	    return n2;
    }

    static void addAct(ZZCell s, String name, String act, ZZCell after) {
	ZZCell c = addAct(s, name, act);
	after.insert("d.3", 1, c);
    }

    static void setModeColor(ZZCell mode, Color col) {
	if(col == null) {
	    if(mode.s("d.color") != null)
		mode.disconnect("d.color", 1);
	} else {
	    ZZCell c = mode.getOrNewCell("d.color", 1);
	    c.setText(String.valueOf(col.getRGB()));
	}
    }

    /** Puts a number of default key bindings to the structure.
     * ZZKeyBindings1 structure is assumed (list on d.2 of keys 
     * and on d.1 the responses)
     */
    static public void putDefBinds(ZZCell start, ZZCell editstart) {
	    start.setText("Normal mode");
	    editstart.setText("Text edit bindings");

	    // Apparently, this wasn't actually necessary!
	    /*
	    ZZCell dir = start.N("d.2", 1);
	    dir = dir.N("d.3", -1);
	    dir.setText("Motion");
	    */
	    ZZCell dir = start;

	    ZZCell editmode = start.N("d.1", 1);
	    setModeColor(editmode, Color.white);
	    
	    editmode.setText("Edit mode");
	    editmode.N("d.2").setText("EDITBINDS");
	    addAct(editmode, "Tab", "SWITCHOFFCURSMODE", dir);
	    addAct(editmode, "Esc", "SWITCHOFFCURSMODE", dir);

	    ZZCell curs = editstart;
	    curs.setText("Text edit mode");
            addAct(curs, "Ctrl-A", "CTXTSOL");
            addAct(curs, "Ctrl-E", "CTXTEOL");
            addAct(curs, "End", "CTXTEND");
            addAct(curs, "Home", "CTXTHOME");              
	    addAct(curs, "Right", "CTXTCRSR +");
	    addAct(curs, "Left", "CTXTCRSR -");
	    addAct(curs, "Backspace", "CTXTBKSP");
	    addAct(curs, "Delete", "CTXTDEL");
	    addAct(curs, "MouseClicked1", "MOUSESETCTXT");
	    addAct(curs, "DEFAULT", "CTXTINSERT");


            ZZCell cursel = editmode.N("d.1", 1);
            cursel.setText("Cursel mode");
	    cursel.N("d.color").setText("CURSOR");
	    
            addAct(cursel, " ", "", dir);
            addAct(cursel, "Esc", "", dir);
	    addAct(cursel, "Alt-C", "", dir);
            addAct(cursel, "Left", "CURSEL -");
            addAct(cursel, "Right", "CURSEL +");
            addAct(cursel, "Up", "SELEVATE -");
            addAct(cursel, "Down", "SELEVATE +");

            addAct(cursel, "j", "CURSEL -");
            addAct(cursel, "l", "CURSEL +");
            addAct(cursel, "i", "SELEVATE -");
            addAct(cursel, ",", "SELEVATE +");
        
            addAct(cursel, "s", "CURSEL C-");
            addAct(cursel, "f", "CURSEL C+");
            addAct(cursel, "e", "SELEVATE C-");
            addAct(cursel, "c", "SELEVATE C+");

	    // Quote starts insert buffer mode...
	    ZZCell bufins = cursel.N("d.1", 1);
	    bufins.setText("Quotebuf");
	    setModeColor(bufins, Color.pink);
	    
	    addAct(bufins, "DEFAULT", "APPENDINPUT");
	    addAct(bufins, "Backspace", "BACKSPACEINPUT");
	    addAct(bufins, "\"", "", dir);
	    addAct(bufins, "Esc", "", dir);

	    // Totally temporary
	    addAct(dir, "Tab", "SWITCHCURSMODE", editmode);
	    addAct(dir, "Alt-C", "", cursel);

	    addAct(dir, "\"", "CLRINPUT", bufins);

	    addAct(dir, "l", "CRSR X+");
	    addAct(dir, "j", "CRSR X-");
	    addAct(dir, "i", "CRSR Y-");
	    addAct(dir, ",", "CRSR Y+");
	    addAct(dir, "k", "CRSR Z+");
	    addAct(dir, "K", "CRSR Z-");

	    // Caps locked
	    addAct(dir, "L", "CRSR X+");
	    addAct(dir, "J", "CRSR X-");
	    addAct(dir, "I", "CRSR Y-");

	    addAct(dir, "a", "MONOCHUG");
	    
	    addAct(dir, "f", "CRSR CX+");
	    addAct(dir, "s", "CRSR CX-");
	    addAct(dir, "e", "CRSR CY-");
	    addAct(dir, "c", "CRSR CY+");
	    addAct(dir, "d", "CRSR CZ+");
	    addAct(dir, "D", "CRSR CZ-");

	    // Caps locked
	    addAct(dir, "F", "CRSR CX+");
	    addAct(dir, "S", "CRSR CX-");
	    addAct(dir, "E", "CRSR CY-");
	    addAct(dir, "C", "CRSR CY+");

	    addAct(dir, "Right", "CRSR X+");
	    addAct(dir, "Left", "CRSR X-");
	    addAct(dir, "Up", "CRSR Y-");
	    addAct(dir, "Down", "CRSR Y+");
	
	    addAct(start, "Ctrl-C", "PUICOPY");
	    addAct(start, "Ctrl-Shift-C", "PUICOPYLINE");
	    addAct(start, "Ctrl-Alt-C", "PUICOPYRANK");
	    addAct(start, "Ctrl-V", "PUIPASTE");

	    addAct(start, "-", "CNCTI" /*, dir */);
	    addAct(start, "n", "NEW" /*, dir */);
	    // XXX Problem: must switch to edit mode AFTER arrow
	    // addAct(start, "N", "NEWANDEDIT", editmode);
	    addAct(start, "b", "DISC" /*, dir */);
	    addAct(start, "/", "CNCTPAIR" /*, dir */);
	    addAct(start, "t", "CLONE" /*, dir */);
	    addAct(start, "T", "CLONECTRL" /*, dir */);
	    addAct(start, "o", "ORIGINAL");
	    addAct(start, "O", "ORIGINAL CTRL");
	    addAct(start, "Alt-O", "NEXTCLONE");
	    addAct(start, "Alt-Shift-O", "NEXTCLONE CTRL");
	    addAct(start, "h", "HOP" /*, dir */);
	    addAct(start, "H", "HOP" /*, dir */);

	    addAct(start, "%", "EXCHANGECELLS");

	    addAct(start, "Ctrl-X", "EXCISE");

	    addAct(start, "End", "END" /*, dir */);

	    for(int i=0; i<=9; i++) 
		addAct(start, ""+i, "APPENDINPUT");
	    addAct(start, "Backspace", "BACKSPACEINPUT");

	    addAct(start, "g", "GOTO");
	    addAct(start, "G", "GOTO CTRL");

	    addAct(start, "Esc", "HOMECLR");
	    addAct(start, "Home", "HOME");


	    addAct(start, "v", "RASTER +");
	    addAct(start, "Alt-V", "RASTER -");
	    addAct(start, "V", "RASTER C+");
	    addAct(start, "Alt-Shift-V", "RASTER C-");

	    addAct(start, "F2", "FFACTORY +");
	    addAct(start, "Alt-F2", "FFACTORY -");
	    addAct(start, "Shift-F2", "FFACTORY C+");
	    addAct(start, "Alt-Shift-F2", "FFACTORY C-");
	    

	    addAct(start, "F3", "SORTALPH");

	    addAct(start, "x", "DIM X+");
	    addAct(start, "Alt-X", "DIM X-");
	    addAct(start, "y", "DIM Y+");
	    addAct(start, "Alt-Y", "DIM Y-");
	    addAct(start, "z", "DIM Z+");
	    addAct(start, "Alt-Z", "DIM Z-");


	    addAct(start, "X", "DIM CX+");
	    addAct(start, "Alt-Shift-X", "DIM CX-");
	    addAct(start, "Y", "DIM CY+");
	    addAct(start, "Alt-Shift-Y", "DIM CY-");
	    addAct(start, "Z", "DIM CZ+");
	    addAct(start, "Alt-Shift-Z", "DIM CZ-");

	    addAct(start, "~", "SWAPCRSR");
	    addAct(start, "<", "FETCH");
	    addAct(start, ">", "FETCH CTRL");
	
	    addAct(start, "Ctrl-<", "ACCURSE CTRL");
	    addAct(start, "Ctrl->", "ACCURSE");

	    // addAct(start, "Alt-x", "PSHDIM X+");
	    // addAct(start, "Alt-y", "PSHDIM Y+");
	    // addAct(start, "Alt-z", "PSHDIM Z+");


	    

	/*
	    addAct(start, "L", "MARK X+");
	    addAct(start, "J", "MARK X-");
	    addAct(start, "I", "MARK Y-");
	    addAct(start, "<", "MARK Y+");
	*/

	    addAct(start, "Enter", "EXEC");


	    addAct(start, "m", "MARK");

	    addAct(start, "u", "UNDO");
	    addAct(start, "Ctrl-U", "REDO");
	    addAct(start, "Ctrl-S", "COMMIT");

	    addAct(start, "Ctrl-F", "FINDTEXT");

	    addAct(start, "MouseClicked1", "MOUSESETC");
	    addAct(start, "MouseClicked2", "MOUSEEXEC");
	    addAct(start, "MouseClicked3", "MOUSEMARK");

	    addAct(start, "Delete", "DELETESCRAM");

	    addAct(start, "F1", "HELP");
	    addAct(start, "q", "QUIT");
    }

    static public void putDefTextBinds(ZZCell start) {
	start.setText("Text insert mode");
	ZZCell dir = start;
	addAct(dir, "DEFAULT", "TXTINSERT");
    }
    static public void putDefCmds(ZZCell fromHome) {
	    String [][] foo = {
		    { "EDITHACK" },
		    {},
		    { "NEWVIEWS" },
		    { "TextCloud.TESTWIN" }, 
/* doesn't work currently
		    { "ZZMbox.READMBOX", "ZZMbox.CREATEFLOBWINDOW" },
*/
		    { "NileDemo.UPDATE" },
		    { "SplitNileDemo.UPDATE" },
		    { "CreateCursors" },
		    { "UPDATEWINS" },
                    { "EDITVIEW" } ,
		    { "XML.IMPORT" } /* , 
		    { "---- (obsolete?)" },
		    { "CNCT X+", "CNCT X-" },
		    { "CNCT Y+", "CNCT Y-" },
		    { "CNCTI X+", "CNCTI X-" },
		    { "CNCTI Y+", "CNCTI Y-" },
		    { "CNCTC X+", "CNCTC X-" },
		    { "CNCTC Y+", "CNCTC Y-" },
		    { "SETDIMS", "SETCDIMS" },
		    //{ "RENDER" },
		    { "TestClang1.1" },
		    { "QUIT" }, */
	    };
	    ZZCell curv = fromHome;
	    for(int i=0; i<foo.length; i++) {
		    curv = curv.N("d.2", 1);
		    ZZCell curh = curv;
		    for(int j=0; j<foo[i].length; j++) {
			    if(j>0) curh = curh.N("d.1", 1);
			    curh.setText(foo[i][j]);
		    }
	    }
	    if(true) {
		foo = new String[][]{
		    { "Dumper.Create" },
		    { "Dumper.Read" },
		    { "Dumper.Write" },
		    { "Dumper.Dump" },
		    { "Dumper.Enter" },
		    { "Dumper.ChangeID" },
		    { "HOME" },
		};
		curv = fromHome.N("d.1", 1);
		// curv.setText("Dumping"); // XXX -- set or don't?
					    // (what's less confusing?)
		for(int i=0; i<foo.length; i++) {
		    curv = curv.N("d.2", 1);
		    ZZCell curh = curv;
		    for(int j=0; j<foo[i].length; j++) {
			    if(j>0) curh = curh.N("d.1", 1);
			    curh.setText(foo[i][j]);
		    }
		}
	    }
	    if(false) {
		foo = new String[][]{
		    { "SNDS T0-", "SNDS T0+" },
		    { "SNDS T1+", "SNDS T1-" },
		    { "SNDL T0-", "SNDL T0+" }, // locked to the other one
		    { "SNDL T1+", "SNDL T1-" },
		    { "SNDSPLIT", "SNDJOIN+" },
		    { "ZZPlayer.PLAY", "ZZPlayer.PLAYLOOP", 
		    	"ZZPlayer.PAUSE", "ZZPlayer.STOP" },
		    { "ZZPlayer.CRDEMO" },
		};
		curv = fromHome.N("d.1", 1);
		curv.setText("Sound");
		for(int i=0; i<foo.length; i++) {
		    curv = curv.N("d.2", 1);
		    ZZCell curh = curv;
		    for(int j=0; j<foo[i].length; j++) {
			    if(j>0) curh = curh.N("d.1", 1);
			    curh.setText(foo[i][j]);
		    }
		}
	    }
    }
}