Tcl Source Code

      id='tcl'
      width=0 height=0
      nacl='tcl.nmf'
      type='application/x-nacl'
      onload='moduleDidLoad();'
      verbose=0
      source='NaTk.tcl'

      toplevel='toplevel'/>

   <div id="toplevel">Loading ...</div>

   <script id='script' type="text/tcl">
     # this script will be evaluated by NaTk
     button .b -text "Hello, Tk!" -command {alert HELLO} -grid {0 0}
   </script>

  </body>
</html>

            checkbutton radiobutton scale
            select combobox frame
        } {
            Interp alias $n [self] mkwidget $n
        }
        Interp alias $n grid [self] grid

        #::dom get [dict get $::argv script] [self] start
    }
}

class create ::NaTk::Widget {
    variable id props widget interp parent connection
    method js {} {return ""}

}

Debug on form
Debug on widgets
Debug on widget
Debug on interp

set ::nacl::verbose 1

# fetch all the <script> elements which are type text/tcl
# pass them as one big string to the NaTk object for evaluation.
::nacl js "runTclScripts('[::NaTk new] start')"

    try {
	eval(t);
    } catch(err) {
	//printf("JS-err:", err);
	setTimeout('tcl("::nacl::bgerror,"'+ err + ',' + t + ')',0);
    }
}

function serialT (thing) {
    alert("serialT " + thing.type + " " + thing.toString());
    var result = '{';
    switch (thing.type) {

    case 'string':
        return tclEsc(thing);
        break;

    case 'array':
        for (var i=0; i < thing.length(); i++) {
            result = result + " " + serialT(thing[i]);
        }
        result = result + '}';
        break;

    case 'object':
        for (var prop in thing) {
            result = result + " " + serialT(prop) + " " + serialT(thing[prop]);
        }
        result = result + '}';
        break;

    case 'function':
        result = thing.toString();
        break;

    default:
        return undefined;
        break;
    }
    return result;
}

function callback(to,js) {
    alert("callback " + to + " " + js);
    try {
	tclDo(to + " " + serialT(eval(js)));
    } catch (err) {
        alert("JS-error " + err);
	//printf("JS-err:", err);
	setTimeout('tcl("::nacl::bgerror,"'+ err + ',' + js + ')',0);
    }
}

// --- tclsource starts an XHR, and calls the given 'tcb' (Tcl
// --- Callback) on completion. A catchable Tcl-level error is raised
// --- in case of not-200. Used by [source].
function tclsource(url,tcb) {
    //printf('tclsource');
    xs = new XMLHttpRequest();

		    tclDo(tcb+" {"+xs.responseText+"}");
		} else {
		    tclDo(tcb+" {error \"Can't source -- "+xs.statusText+"\"}");
		}
	    }
    };
}

// traverse - apply function to subtree of dom returning object
function traverse(fn)
{
        var result;
        var target;
        if (arguments.length() > 1) {
           target = arguments[1];
        } else {
          target = document;
        }

        result[target]=fn.apply(target);

        for (var i=0; i<target.childNodes.length; i++) {
            var child = target.childNodes[i];
            var traversal = traverse(fn, child);
            for (var prop in traversal) {
               result[prop] = traversal[prop];
            }
	}

        return result;
}

// ---------- GUI and standard NaCl-loading machinery --------

function moduleDidLoad() {
    tclModule = document.getElementById('tcl');
    // tcl('lappend', '::JS', "alert('ARGV:[join $::argv]')");
    tcl('eval', 'coroutine', '::main_coro', 'source', '[dict get $::argv source]');
}

// runTclScripts - collect all <script> elements with type text/tcl
// Pass them to the Tcl header given in 'where' (or uplevel)
function runTclScripts(where) {
    if (where == undefined) {
        where = "uplevel #0";
    }

    var scripts = document.getElementsByTagName('script');
    var script = "";
    for (var i = 0; i < scripts.length; i++) {
        if (scripts[i].getAttribute('type') == 'text/tcl') {
            script = script + '\n' + scripts[i].innerHTML;
        }
    }
    tclDo(where + " {" + tclEsc(script)+ "}");
}

        uint32_t len = 0;
        int i;

        args[0] = Tcl_NewStringObj("::nacl::evall",-1);
        Tcl_IncrRefCount(args[0]);

        for (i = 0; i < argc; i++) {
            if (argv[i].type == PP_VARTYPE_STRING) {


                const char *bytes = var_interface->VarToUtf8(argv[i], &len);
                args[i+1] = Tcl_NewStringObj(bytes, len);
                Tcl_IncrRefCount(args[i+1]);
                if (verbose) {
                    printf("NaTcl(%d): EVALL arg: '%s'\n",pid, bytes);
                }
            } else {
                v = StrToVar("Arg from Javascript is not a string!");
            }
        }

        Tcl_EvalObjv(interp, argc+1, args, 0);

        if (verbose) {
            printf("NaTcl(%d): EVALL result: '%s'\n",pid, Tcl_GetStringResult(interp));
        }

        for (i = 0; i < argc+1; i++) {
            Tcl_DecrRefCount(args[i]);
        }