append upgrade	"WebSocket-Location: ws://localhost:9001/wsctrl\r\n"
		append upgrade "Sec-WebSocket-Accept: $acceptKey"
		append upgrade "\r\n\r\n"
		fconfigure $sock -translation binary
		puts -nonewline $sock $upgrade
		flush $sock
		fileevent $sock readable [list ws_receive junk $sock]

		set sessionid [lindex [split [dict get $data query] =] end]
		puts "Socket $sock upgraded to WebSocket for sessionid $sessionid"	
		dict set ::session($sessionid) wsock $sock
		dict set ::sock($sock) sessionid $sessionid

		#use this after full message frames are implemented
		#toclient $sessionid [dict get $::session($sessionid) msgq] 
		
		#for now I dish out small chucks of js to fit the 126 byte message length
		foreach message [split [string range [dict get $::session($sessionid) msgq] 0 end-1] \;] {
			#toclient $sessionid ${message};
			puts "WSSERVERA: ${message};"
			ws_send $sock "${message};"
			update idletasks
		}
		
		dict set ::session($sessionid) msgq ""
		
		return 1
	} else {
		#puts "\nVersion != 13 no good"
		close $sock
		return 0
	}
}

		httpd loadrequest $sock data query
		if {![info exists data(url)]} {return}
		regsub {(^http://[^/]+)?} $data(url) {} url
		puts stderr "URL: $url"
		set url [string trimleft $url /]
		switch -glob -- $url {
			""             {httpd return $sock [filecontents index.html]}
			"*.tcl"        {httpd return $sock [newSession $sock [string trimleft $url /] lib/wtkcoreapp.html [array get data]]}
			"*.js"         {httpd return $sock [filecontents $url] -mimetype "text/javascript"}
			"*.gif"        {httpd returnfile $sock $url $url  "image/gif" [clock seconds] 1 -static }
			"*.png"        {httpd returnfile $sock $url $url  "image/png" [clock seconds] 1 -static }
			"*.jpg"        {httpd returnfile $sock $url $url  "image/jpg" [clock seconds] 1 -static }
			"*.ico"        {httpd returnfile $sock $url $url  "image/x-icon" [clock seconds] 1 -static }
			"wtkpoll.html" {if !{[sendany $sock $query(sessionid)]} {error "pending"}}
			"wtkcb.html"   {fromclient $query(sessionid) $query(cmd)}

# This is called when a client first loads one of our 'application' pages.  We create a new
# application instance (interpreter), load and initialize "wtk" in that interpreter, and then
# load in the Tcl script for the application we're running.  We return a HTML page that will
# load up the client side of wtk and cause the browser to initiate a connection back to the
# server. Notably, this page includes the 'sessionid' we've generated for the application
# instance, which is unique to each client.

proc newSession {sock script webpage data} {
	set sessionid [incr ::sessioncounter]
	set interp [interp create]
	dict set ::session($sessionid) interp $interp
	dict set ::session($sessionid) msgq ""
	dict set ::session($sessionid) sock $sock
	dict set ::session($sessionid) wsock 0
	if {[catch {$interp eval source lib/wtk-base.tcl}]!=0} {puts $::errorInfo}
	$interp alias sendto toclient $sessionid
	$interp eval wtk::init sendto
	#pass in the server header vars first
	$interp eval [list set ::reqdata $data]
	#now source the app script
	if {[catch {$interp eval source $script}]!=0} {puts $::errorInfo}
	if {[file exists favicon.ico]} {
		set link "<link href='data:image/x-icon;base64,%%%BASE64ICO%%%' rel='icon' type='image/x-icon' />"
		set favicon [string map "%%%BASE64ICO%%% [binary encode base64 [filecontents favicon.ico]]" $link]
	} else {
		set favicon ""
	}

var wtk = {
    
    widgets : new Array(),
    objs : new Array(),

		pause : function(ms) {
			ms += new Date().getTime();
			while (new Date() < ms){}
		},
  
    /*
     *   Initialize, and manage two AJAX connections to the server; one is used to send
     *   messages, and the other polling connection is used to receive messages.  These
     *   correspond to the routines in server.tcl, and could be equally well replaced by
     *   a different and/or more reliable communications channel.
     */

					ws_uri += "/wsctrl";
					ws_uri += "?sessionid=" + sessionid;
					
					wtk.connection = new WebSocket(ws_uri);

					wtk.connection.onopen = function(){
				 		/*Send a small message to the console once the connection is established */
				 		console.log('WebSocket connection open');
						wtk.conntype = "websocket";
						wtk.wsfailcnt = 0;
					};

					wtk.connection.onclose = function(){
				 		console.log('WebSocket connection closed');
						if (wtk.conntype = "websocket" && wtk.wsfailcnt <= 4) {
							console.log('WebSocket connection retry '+wtk.wsfailcnt+' of 4');
							wtk.pause(1000);
							wtk.wsfailcnt = wtk.wsfailcnt + 1;
							wtk.init();
						} else {
							console.log('Initiating AJAX fallback connection');
							setTimeout(wtk.poller,100);
						};
					};

					wtk.connection.onerror = function(error){
						console.log('WebSocket Error detected: ' + error);
					};

					wtk.connection.onmessage = function(e){
						var server_message = e.data;
						//console.log(server_message);
						eval(server_message);

					};








				} else {
			 		/*WebSockets are not supported. Fallback to long-polling */
					console.log('Browser doesnt support WebSockets, using AJAX instead');
					setTimeout(wtk.poller,100);
				};


    },



    poller : function() {$.ajax({type:'GET', url:'wtkpoll.html?sessionid='+wtk.sessionid, dataType:'script', 
                                complete: function() {setTimeout(wtk.poller,100);},
                                error: function(jqXHR, textStatus, errorThrown) {
																	//alert("AJAX server connection interrupted\nPress OK to reconnect.");
																	console.log('AJAX server connecton interrupted '+textStatus+' '+errorThrown);
																	setTimeout(location.reload(1),200);}
                               });
												 },

    sendto : function(msg) { 
      if (wtk.conntype != "websocket") {
				$.get('wtkcb.html?sessionid='+wtk.sessionid, {cmd : msg});