WebTerminal-0.9.9.5-dev.xml

<?xml version="1.0" encoding="UTF-8"?>
<Export generator="Cache" version="25">
<Class name="%WebTerminal.Engine">
<Description>
This class represents the core of web terminal.
All operations with opened WebSocket placed here.</Description>
<Super>%CSP.WebSocket,%Library.Routine</Super>
<TimeCreated>63047,60359.445979</TimeCreated>

<UDLText name="T">
<Content><![CDATA[
// USER CONSTANTS START

]]></Content>
</UDLText>

<Parameter name="authorizationTimeout">
<Description>
How long to wait for authorization key when connection established</Description>
<Default>5</Default>
</Parameter>

<UDLText name="T">
<Content><![CDATA[
// USER CONSTANTS END

]]></Content>
</UDLText>

<Property name="SharedConnection">
<Description><![CDATA[
This property determines whether the communication between the client and WebSocket server should be over a dedicated Gateway
conection or over a pool of shared connections.  It may be set to one of the following:
<br><ul>
<li><b>SharedConnection=0</b> - The WebSocket server communicates with the client via a dedicated Gateway connection. In this mode of operation the hosting connection is effectively 'private' to the application session.</li>
<li><b>SharedConnection=1</b> - The WebSocket server communicates asynchronously with the client via a fixed number of shared Gateway connections.</li>
</ul>]]></Description>
<Type>%Boolean</Type>
<InitialExpression>0</InitialExpression>
</Property>

<Property name="lastClientId">
<Description>
Last joined client id</Description>
<Type>%Numeric</Type>
<InitialExpression>0</InitialExpression>
</Property>

<Property name="ConstServerActionExecute">
<Type>%Char</Type>
<InitialExpression>$c(1)</InitialExpression>
</Property>

<Property name="ConstServerActionExecuteSQL">
<Type>%Char</Type>
<InitialExpression>$c(2)</InitialExpression>
</Property>

<Property name="ConstServerActionGenerateAutocomplete">
<Type>%Char</Type>
<InitialExpression>$c(3)</InitialExpression>
</Property>

<Property name="ConstServerActionWatch">
<Type>%Char</Type>
<InitialExpression>$c(4)</InitialExpression>
</Property>

<Property name="ConstServerActionCheckWatches">
<Type>%Char</Type>
<InitialExpression>$c(5)</InitialExpression>
</Property>

<Property name="ConstServerActionReset">
<Type>%Char</Type>
<InitialExpression>$c(6)</InitialExpression>
</Property>

<Property name="ConstServerActionEcho">
<Type>%Char</Type>
<InitialExpression>$c(7)</InitialExpression>
</Property>

<Parameter name="ConstServerActionExecuteStack">
<Expression>$c(8)</Expression>
</Parameter>

<Property name="ConstClientEnterClearIO">
<Type>%Char</Type>
<InitialExpression>$c(1)</InitialExpression>
</Property>

<Property name="ConstClientExitClearIO">
<Type>%Char</Type>
<InitialExpression>$c(2)</InitialExpression>
</Property>

<Property name="ConstClientOutputMessage">
<Type>%Char</Type>
<InitialExpression>$c(3)</InitialExpression>
</Property>

<Property name="ConstClientChangeNamespace">
<Type>%Char</Type>
<InitialExpression>$c(4)</InitialExpression>
</Property>

<Property name="ConstClientLoadAutocomplete">
<Type>%Char</Type>
<InitialExpression>$c(5)</InitialExpression>
</Property>

<Property name="ConstClientReadString">
<Type>%Char</Type>
<InitialExpression>$c(6)</InitialExpression>
</Property>

<Property name="ConstClientReadChar">
<Type>%Char</Type>
<InitialExpression>$c(7)</InitialExpression>
</Property>

<Property name="ConstClientAuthorizationStatus">
<Type>%Char</Type>
<InitialExpression>$c(8)</InitialExpression>
</Property>

<Property name="ConstClientWatch">
<Type>%Char</Type>
<InitialExpression>$c(9)</InitialExpression>
</Property>

<Property name="ConstClientLoginInfo">
<Type>%Char</Type>
<InitialExpression>$c(10)</InitialExpression>
</Property>

<Property name="CurrentNamespace">
<Type>%String</Type>
</Property>

<Property name="InitialZName">
<Type>%String</Type>
</Property>

<Property name="Watches">
<Description>
Property is used to store watching files/globals. </Description>
<Type>%List</Type>
</Property>

<Property name="WatchesCaret">
<Description>
Watch position in file on global</Description>
<Type>%Numeric</Type>
<MultiDimensional>1</MultiDimensional>
</Property>

<Method name="redirects">
<Description>
Public point entries, using when redirecting i/o</Description>
<Internal>1</Internal>
<Private>1</Private>
<ProcedureBlock>0</ProcedureBlock>
<Implementation><![CDATA[
PrepareOutput(data)
	Try { Set data=$zconvert(data,"O","UTF8") } Catch {  }
	quit data
	
PrepareInput(data)
	Try { Set data=$zconvert(data,"I","UTF8") } Catch {  }
	quit data
	
//////////////////////////////////////////////
	
wstr(s)
	do ##class(%Device).ReDirectIO($$$NO) 
	w $$PrepareOutput(s),*-3
	do ##class(%Device).ReDirectIO($$$YES)
	quit 
wchr(c) 
	do ##class(%Device).ReDirectIO($$$NO) 
	w $$PrepareOutput($c(c)),*-3
	do ##class(%Device).ReDirectIO($$$YES) 
	quit
wnl 
	do ##class(%Device).ReDirectIO($$$NO) 
	w $c(13,10),*-3
	do ##class(%Device).ReDirectIO($$$YES)
	quit 
wff 
	do ##class(%Device).ReDirectIO($$$NO) 
	w $c(12),*-3
	do ##class(%Device).ReDirectIO($$$YES)
	quit 
wtab(s)
	do ##class(%Device).ReDirectIO($$$NO) 
	w $$PrepareOutput($j("",s-$x)),*-3
	do ##class(%Device).ReDirectIO($$$YES) 
	quit
	
rstr(len = 32656,timeout = 86400)
	do ##class(%Device).ReDirectIO($$$NO)
	w $c(6),*-3 // ..ConstClientReadString
	
	use $io:(::"+T")
	read data#5:timeout // package header
	read data:timeout
	use $io:(::"-T")
	
	set data = $$PrepareInput($EXTRACT(data,1,len))
	do ##class(%Device).ReDirectIO($$$YES)
	quit data
rchr(timeout = 86400)
	do ##class(%Device).ReDirectIO($$$NO)
	w $c(7),*-3 // ..ConstClientReadChar
	
	use $io:(::"+T")
	read data#5:timeout // package header
	read data:timeout
	use $io:(::"-T")
	
	set data = $$PrepareInput($ASCII($EXTRACT(data,1,1)))
	do ##class(%Device).ReDirectIO($$$YES)
	quit data
]]></Implementation>
</Method>

<Method name="OnPreServer">
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	quit $$$OK
]]></Implementation>
</Method>

<Method name="AddWatch">
<Description>
Chechs for correct watch source and sets watch target to ..Watches
Returns status of this operation</Description>
<FormalSpec>name</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	set s = $CHAR(0)
	set watches = s _ $LISTTOSTRING(..Watches, s) _ s
	if ($FIND(watches, s_name_s) '= 0) q 0 // if watch already defined
	
	if ($EXTRACT(name,1,1) = "^") { // watching global
		s g = 0
		try {
			if (($data(@name))'=0) s g = 1
		} catch {  }
		set $ZERROR = ""
		if (g = 1) {
			set ..Watches = ..Watches _ $LISTBUILD(name)
			set ..WatchesCaret(name,0) = $QUERY(@name@(""),-1) // last
			set ..WatchesCaret(name,1) = "?"
			do ..SendData(name, ..ConstClientWatch)
			q 1
		}
	} else { // watch file
		if (##class(%File).Exists(name)) {
			set ..Watches = ..Watches _ $LISTBUILD(name)
			set file = ##class(%File).%New(name)
			set ..WatchesCaret(name,0) = file.Size // current watch cursor position
			set ..WatchesCaret(name,1) = file.DateModified
			do ..SendData(name, ..ConstClientWatch)
			q 1
		}
	}
	
	q 0 // what do you want?
]]></Implementation>
</Method>

<Method name="RemoveWatch">
<Description>
Removes watch from watches list
Returns success status</Description>
<FormalSpec>name</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	// absurdly, but working
	set s = $CHAR(0)
	set watches = s _ $LISTTOSTRING(..Watches,s) _ s
	set newWatches = $REPLACE(watches, s_name_s, s)
	set ..Watches = $LISTFROMSTRING($EXTRACT(newWatches, 2, *-1), s)
	if (watches '= newWatches) {
		k ..WatchesCaret(name) // really removed
		do ..SendData(name, ..ConstClientWatch)
	}
	quit watches '= newWatches
]]></Implementation>
</Method>

<Method name="ListWatches">
<Description>
Returns a list current watches</Description>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set no=0
	set s = "Watching: " _ $CHAR(10)
    while $LISTNEXT(..Watches, no, value) {
    	set s = s_"(pos: "_..WatchesCaret(value,0)_
    	"; mod: "_..WatchesCaret(value,1)_") "_value_$CHAR(10)
    }
    q s
]]></Implementation>
</Method>

<Method name="GetWatchGlobalModified">
<Description>
Return null string if global hadn't been updated
This method watches only for tail of global and detects if global still alive</Description>
<FormalSpec>watch</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set data = ""
	if ($data(@watch)=0) {
		do ..RemoveWatch(watch)
		q "removed"
	}
	for {
    	set query = $QUERY(@..WatchesCaret(watch,0))
        quit:query=""
        if (data="") set data = "modified"
        set ..WatchesCaret(watch,0) = query
        set data = data _ $CHAR(10) _ @query
  	}
  	q data
]]></Implementation>
</Method>

<Method name="GetWatchFileModified">
<FormalSpec>watch</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set file=##class(%File).%New(watch)
	set size = file.Size
	set modDate = file.DateModified
	set output = ""
	if (size < 0) { // file had been deleted
		 
		do ..RemoveWatch(watch)
		q "removed"
		
	}
	if (size > ..WatchesCaret(watch, 0)) {
		
		set output = "updated" _ $CHAR(10)
		set stream=##class(%Stream.FileBinary).%New()
		set sc=stream.LinkToFile(watch)
		do stream.MoveTo(..WatchesCaret(watch, 0) + 1)
		set readed = stream.Read(size - ..WatchesCaret(watch, 0))
		set output=output_readed
		set ..WatchesCaret(watch, 0) = size
		set ..WatchesCaret(watch, 1) = file.DateModified
		
	} elseif ((size < ..WatchesCaret(watch, 0)) || (file.DateModified '= ..WatchesCaret(watch, 1))) {
		
		set output = "modified" _ $CHAR(10)
		set output = output _ "Bytes changed: " _ (size - ..WatchesCaret(watch, 0))
		set ..WatchesCaret(watch, 0) = size
		set ..WatchesCaret(watch, 1) = file.DateModified
		
	} // else file not changed
	q output
]]></Implementation>
</Method>

<Method name="CheckWatches">
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set no = 0
	set data = ""
	set overal = ""
	set watchList = ..Watches // do not remove or simplify: ..Watches can be modified
    while $LISTNEXT(watchList, no, value) {
    	if ($EXTRACT(value, 1, 1) = "^") {
  			set data = ..GetWatchGlobalModified(value)
    	} else {
	    	set data = ..GetWatchFileModified(value)
    	}
    	if (data '= "") {
	    	set overal = $ZDATETIME($NOW(),1,1) _ " " _
	    	value _ ": " _ data _ $CHAR(10)	
    	}
    	set data = ""
    }
    q overal
]]></Implementation>
</Method>

<Method name="OnPostServer">
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	kill ^CacheTemp.WebTerminal.Watching
 	quit $$$OK
]]></Implementation>
</Method>

<Method name="GetJSAutocompleteFilePath">
<ClassMethod>1</ClassMethod>
<FormalSpec>namespace:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	
	set data = ##class(%Library.File).ManagerDirectory()
	set data = ##class(%Library.File).ParentDirectoryName(data)
	set data = data _ "CSP\sys\webTerminal\js\autocomplete\" _
		$REPLACE(namespace,"%","_") _ ".js" // UNIX?
	quit data
]]></Implementation>
</Method>

<Method name="WriteToFile">
<ClassMethod>1</ClassMethod>
<FormalSpec>filename:%String,data:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	set file=##class(%File).%New(filename)
	do file.Open("WSN")
	do file.WriteLine(data)
	do file.Close()
]]></Implementation>
</Method>

<Method name="getGlobalsJSON">
<ClassMethod>1</ClassMethod>
<FormalSpec>namespace:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[

	set out = "{"
 	set rset=##class(%ResultSet).%New("%SYS.GlobalQuery:NameSpaceList")
 	set sc=rset.Execute($ZNSPACE,"*",0)
  	while (rset.Next()) {
		set out = out _ """" _ $Piece(rset.GetData(1),"(",1) _ """:0,"
  	}
  	set out = $EXTRACT(out,1,$LENGTH(out)-1) _ "}"
	q out
]]></Implementation>
</Method>

<Method name="GenerateAutocompleteFile">
<Description>
Generates autocomplete file for namespace. Second parameter deсides if
it will be regenerated again. But if namespace equals to "%" - generates
autocomplete file for system classes. Make sure that autocomplete for
system classes generates one time and forever. </Description>
<FormalSpec>namespace:%String,newFile:%Boolean</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	
	set filename = ..GetJSAutocompleteFilePath($NAMESPACE)
	
	set system = 0
	if (namespace = "%") {
		set namespace = "%SYS"
		set filename = ..GetJSAutocompleteFilePath("_")
		set system = 1
	}
	
	if (system) && (##class(%File).Exists(filename)) {
		do ..SendData("_", ..ConstClientLoadAutocomplete)
		quit $$$OK
	}
	
	do ..StartClearIO()
	
	if ('##class(%SYS.Namespace).Exists(namespace)) {
		do ..EndClearIO()
		do ..SendData("Wrong namespace: " _ namespace)
		quit $$$NOTOK
	}
	
	set namespace = $REPLACE(namespace,"%","_")
	
	if (##class(%File).Exists(filename)) && (newFile = 0) {
		
		do ..EndClearIO()
		do ..SendData(namespace, ..ConstClientLoadAutocomplete)
		quit $$$OK
		
	} elseif ('##class(%File).DirectoryExists(##class(%File).GetDirectory(filename))) {
		
		// try to create missed directory
		set result = ##class(%File).CreateDirectoryChain(##class(%File).GetDirectory(filename))
		
		if (result '= 1) {
			do ..EndClearIO()
			do ..SendData("Autocomplete fail: can't create directory js/autocomplete.")
			quit $$$OK
		}
		
	}

	set thisName = $REPLACE(namespace,"_","%")
	if (system) { set thisName = "SYSTEM" }
	do ..SendData("Generating language file for " _ thisName _ ", pleace, wait. ")
		
	// get all classes names
	set result = ##class(%ResultSet).%New("%Dictionary.ClassDefinition:Summary")
	do result.Execute()
	
	/*	
	The next COULD BE IMPROVED FOR SPEED, I beleive.
	Generates compressed JSON string of type:
	{
		"class": {
			"%ClassName1": {
				"methodName": 0,
				"propertyName": 0,
				"parameterName": 0,
				...
			},
			"ClassName2": {
				...
			}
		},
		"global": {
			"^%g1": 0,
			"^g2": 0
		}
	}
	*/
	
	set file=##class(%File).%New(filename)
	do file.Open("WSN")
	
	// final data generation
	do file.Write("{""class"":{")
	set first = ""
	
	while (result.Next()) { // forming autocomplete for each class
	
		set className = result.Data("Name")
		if (($EXTRACT(className,1)="%")'=system) {
			continue
		}
		do file.Write(first _ """" _ className _ """:{")
		if (first = "") set first = ","
		
		set cdefs = ##class(%Dictionary.ClassDefinition).%OpenId(className)
 		
 		set countMethods = cdefs.Methods.Count()
 		set countParameters = cdefs.Parameters.Count()
 		set countProperties = cdefs.Properties.Count()
 		set total = countMethods + countParameters + countProperties
 		set current = 0
 		
 		for i=1:1:countMethods {
	 		set current = current + 1
     		do file.Write("""" _ cdefs.Methods.GetAt(i).Name _ """:0")
     		if (current'=total) do file.Write(",")
 		}
 		
 		for i=1:1:countProperties {
	 		set current = current + 1
     		do file.Write("""" _ cdefs.Properties.GetAt(i).Name _ """:0")
     		if (current'=total) do file.Write(",")
 		}
 		
 		for i=1:1:countParameters {
	 		set current = current + 1
     		do file.Write("""" _ cdefs.Parameters.GetAt(i).Name _ """:0")
     		if (current'=total) do file.Write(",")
 		}
		
		do file.Write("}")
		
	}
	
	do file.Write("}")
	if ('system) {
		do file.Write(",""global"":" _ ..getGlobalsJSON())	
	}
	do file.Write("}")
	do file.Close()
	
	do ..SendData($c(10)_"Language file for " _ thisName _ " generated.")
	
	do ..EndClearIO()
	if (system) {
		do ..SendData("_",..ConstClientLoadAutocomplete)
	} else { do ..SendData(namespace,..ConstClientLoadAutocomplete) }
	
	quit $$$OK
]]></Implementation>
</Method>

<Method name="GenerateAuthKey">
<Description>
Generating new authorization key</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	set ^|"%SYS"|%WebTerminal.AuthKey = $SYSTEM.Util.CreateGUID()
]]></Implementation>
</Method>

<Method name="GetAuthKey">
<Description>
Returns key for client authorization.
If the key is empty, generates new key value.</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	if ($get(^|"%SYS"|%WebTerminal.AuthKey) = "") {
		Do ..GenerateAuthKey()
	}
	quit ^|"%SYS"|%WebTerminal.AuthKey
]]></Implementation>
</Method>

<Method name="Reset">
<Description>
Backs terminal to default state</Description>
<ClassMethod>1</ClassMethod>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	// delete autocompletion files
	set dir = ##class(%File).GetDirectory(..GetJSAutocompleteFilePath("TEST"))
	if (##class(%File).DirectoryExists(dir)) {
		do ##class(%File).RemoveDirectoryTree(dir)
	}
	quit $$$OK
]]></Implementation>
</Method>

<Method name="SendData">
<Description>
Function sends data derectly to server with specified action</Description>
<FormalSpec>query:%String="",action:%String=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	if (action = "") { set action = ..ConstClientOutputMessage }
	do ..Write(action _ query) // using CTWPv3
]]></Implementation>
</Method>

<Method name="ExecuteSQL">
<FormalSpec>query:%String=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
  	do ..StartClearIO()
 	do ##class(%Device).ReDirectIO($$$YES)
	
  	set tStatement = ##class(%SQL.Statement).%New()
  	set qStatus = tStatement.%Prepare(query)
  	if qStatus'=1 {
	  	write "SQL prepare error: ",$System.Status.DisplayError(qStatus)
	} else {
		set rset = tStatement.%Execute()
  		do rset.%Display()
	}
	
	do ##class(%Device).ReDirectIO($$$NO)
	do ..EndClearIO()
	
	quit $$$OK
]]></Implementation>
</Method>

<Method name="ClientAlertNamespace">
<Description>
Sends to client new namespace if last was changed</Description>
<Implementation><![CDATA[
	if (..CurrentNamespace '= $Znspace) { // change client namespace
	    set ..CurrentNamespace = $Znspace
	 	do ..SendData(..CurrentNamespace,..ConstClientChangeNamespace) 
    }
]]></Implementation>
</Method>

<Method name="StartClearIO">
<Description>
Starts clear I/O mode</Description>
<Implementation><![CDATA[
	write *-3
	do ##class(%Device).ReDirectIO($$$YES)
	do ..Write(..ConstClientEnterClearIO)
	write *-3
]]></Implementation>
</Method>

<Method name="EndClearIO">
<Description>
Ends clear I/O mode</Description>
<Implementation><![CDATA[
	write *-3
	do ##class(%Device).ReDirectIO($$$NO)
	do ..SendData("exit",..ConstClientExitClearIO)
	write *-3
]]></Implementation>
</Method>

<Method name="ParseError">
<Description>
This method transforms error </Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>string:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set string = $REPLACE($REPLACE(string, ">", "<"), ".Engine.", "<")
	quit "ERROR: " _ $PIECE(string, "<", 2) _
		$EXTRACT($PIECE(string, "<", 4), 2, *)
]]></Implementation>
</Method>

<Method name="ExecuteCommand">
<Description>
The heart of terminal application</Description>
<FormalSpec>query:%String=""</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	if (query = "") quit $$$OK
	
	#dim exception as %Exception.AbstractException
	set value = $Replace(query,$CHAR(10)," ")
	
	do ..StartClearIO() // execute session start
	
	set $ZERROR = ""
  	
    try { xecute value } catch exception {
	   	set $ZERROR = exception.DisplayString()
	}
	
   	if ($ZERROR '= "") {
		do ..SendData(..ParseError($ZERROR))
   	}
   	
   	do ..EndClearIO() // execute session end
	do ..ClientAlertNamespace() // check namespace change
	
	quit $$$OK
]]></Implementation>
</Method>

<Method name="RequireAuthorization">
<Description>
This method holds process and expects only one package from
the client - it includes authorization key.</Description>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	set authKey = ..Read(,.status,..#authorizationTimeout) // wait for package
	set ok = $$$NOTOK
	
	/*
	 * Find given CSPSessionCookie in session list. If found, grant access
	 */
	SET key = $ORDER(^%cspSession(""))
   	WHILE (key '= "") {
	   	set lb = $GET(^%cspSession(key))
    	if (lb '= "") {
    		if ($LISTGET(lb, 8) = authKey) {
	    		
	    		// setup privileges
	    		ZNSPACE $LISTGET(lb, 7) // namespace
	    		
	    		set user = $LISTGET($LISTGET(lb, 16), 1) // user
	    		set loginStatus = ##class(%SYSTEM.Security).Login($LISTGET($LISTGET(lb, 16), 1))
	    		if ($$$ISOK(loginStatus)) {
					do ..SendData(user,..ConstClientLoginInfo)
	    		} else {
		    		do ..SendData("!",..ConstClientLoginInfo)
	    		}
	    		
	    		set ok = loginStatus
	    		BREAK
	    		
    		}
    	}
    	SET key = $ORDER(^%cspSession(key))
 	}
	
	quit ok
]]></Implementation>
</Method>

<Method name="ClientLoop">
<Description><![CDATA[
Main method for every new client.

Authorization process description:
	1.	Client requests cache server page called "WebTerminal.csp";
	2.	Server return this page with ClassMethod GetAuthKey() value;
	3.	After client receives page, it performs websocket connection;
		to same web-resource, but with next URL changes:
		"http://" -> "ws://", "WebTerminal.csp" -> "Webterminal.Engine.cls";
	4.	After connection established, client sends his AuthKey to server
		and removes it locally (because it needed only one time);
	5.	Server compares again received key with ..GetAuthKey() value and
		grants permission, if keys are equal.
	>>	As a result - there is no way to autorize via websocket without
		accessing WebTerminal.csp.

Method description:
	First, method requires from client 
	a key, which will be compared with ..GetAuthKey() (global). If 
	succeeded, method sets "authorized" flag to true and changes global
	key with ..GenerateAuthKey() for the next client.]]></Description>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	
	kill // clear junk vars
	
	for {
		
		set data = ..Read(,.status)
    
    	if $$$ISERR(status) {
	   
	    	try {
		    	do ..SendData("Error occured while reading data.",
	    		..ConstClientOutputMessage)
	    	} catch e { }
      		quit:($$$GETERRORCODE(status)=$$$CSPWebSocketClosed)
	    	
	   	}
	   	
	   	set action = $EXTRACT(data, 1, 1)
	   	set data = $EXTRACT(data, 2, *)
	   	
	   	if ($EXTRACT(data, *) = $c(10)) { // terminator
		 	set data = $EXTRACT(data, 1, *-1)
	   	}
	   	   	
	    if (action = ..ConstServerActionExecute) { // autorized
	    	
			do ..ExecuteCommand(data)
		    	
	    } elseif (action = ..ConstServerActionCheckWatches) {
	    
		    set changes = ..CheckWatches()
		    if (changes '= "") {
				do ..SendData(changes)   
		    }
		  
	    } elseif (action = ..ConstServerActionWatch) { // add/remove
	    
		    set result = ..AddWatch(data)
		    if ('$$$ISOK(result)) {
				set result = ..RemoveWatch(data)
				if ('$$$ISOK(result)) {
					do ..SendData("!" _ data, ..ConstClientWatch)
				}
		    }
		  
	    } elseif (action = ..ConstServerActionExecuteSQL) { // sql
	    
		    do ..ExecuteSQL(data)
		  
	    } elseif (action = ..ConstServerActionGenerateAutocomplete) {
		    
		    do ..GenerateAutocompleteFile("%", data)
		    do ..GenerateAutocompleteFile(..CurrentNamespace, data)
		    		
	    } elseif (action = ..ConstServerActionReset) {
		      
		    if ($$$ISOK(..Reset())) {
			    do ..SendData("Terminal state reseted.")
		    } else {
			    do ..SendData("Error while reseting terminal state.")
		    }
		    		
	    } elseif (action = ..ConstServerActionEcho) {
		      
		    do ..StartClearIO()
		    write data
		    do ..EndClearIO()
		    		
	    } else { // something scary
		    	
		    do ..SendData("Client request unrecognised: " _ action)
		    		
	    }
      		
	}
]]></Implementation>
</Method>

<Method name="Server">
<Description>
New connection established</Description>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	if ($$$ISOK(..RequireAuthorization())) {
		
		set ..InitialZName = $Zname
		set ..CurrentNamespace = $Znspace
		
		do ..SendData("1", ..ConstClientAuthorizationStatus)
		do ..SendData(..CurrentNamespace, ..ConstClientChangeNamespace)
		   
		use $io::("^" _ ..InitialZName) // switch to routine
		do ..ClientLoop()
		
	} else {
		
		do ..SendData("0", ..ConstClientAuthorizationStatus)
		do ..EndServer()
			
	}
  	
  	quit $$$OK
]]></Implementation>
</Method>
</Class>


<CSP name="WebTerminal/css/base.css" application="/csp/sys/" default="1"><![CDATA[
html {
    position: relative;
    width: 100%;
    height: 100%;
    padding: 0;
    margin: 0;
}

body {
    padding: 20px;
    margin: 0;
    color: white;
    font-family: FreeMono, monospace;
    font-size: 16px;
    background: url("../img/back.png") black;
}

table {
    padding: 0;
    border: 0;
    background: none;
}

tr, td {
    padding: 2px;
    margin: 0;
    border: 0;
    border-spacing: 0;
}

input {
    margin-left: 20px;
}

input:first-child {
    margin-left: 0;
}

p {
    text-indent: 40px;
}]]></CSP>


<CSP name="WebTerminal/css/extra.css" application="/csp/sys/" default="1"><![CDATA[
@-webkit-keyframes blinker {
    0% { opacity: 1.0; }
    50% { opacity: 0.0; }
    100% { opacity: 1.0; }
}

@-o-keyframes blinker {
    0% { opacity: 1.0; }
    50% { opacity: 0.0; }
    100% { opacity: 1.0; }
}

@-moz-keyframes blinker {
    0% { opacity: 1.0; }
    50% { opacity: 0.0; }
    100% { opacity: 1.0; }
}

@keyframes blinker {
    0% { opacity: 1.0; }
    50% { opacity: 0.0; }
    100% { opacity: 1.0; }
}

@keyframes waiting {
    0% { color: orange; }
    50% { color: white; }
    100% { color: orange; }
}

@-moz-keyframes waiting {
    0% { color: orange; }
    50% { color: white; }
    100% { color: orange; }
}

@-o-keyframes waiting {
    0% { color: orange; }
    50% { color: white; }
    100% { color: orange; }
}

@-webkit-keyframes waiting {
    0% { color: orange; }
    50% { color: white; }
    100% { color: orange; }
}

.hidden { display: none; }
.center { text-align: center; }
.bold { font-weight: 900; }
.noMargin { margin: 0 }
.noPadding { padding: 0 }
.normalWrap { white-space: normal; text-wrap: normal }

#caret {
    position: relative;
    display: inline-block;
    width: 0;
    vertical-align: bottom;
    overflow: visible;

    animation: blinker infinite 1s;
    -webkit-animation: blinker infinite 1s;
    -o-animation: blinker infinite 1s;
    -moz-animation: blinker infinite 1s;
}

#caret:after {
    content: "_";
}

.waiting {
    animation: waiting infinite 1s;
    -webkit-animation: waiting infinite 1s;
    -o-animation: waiting infinite 1s;
    -moz-animation: waiting infinite 1s;
}

.animated01 {
    transition: all 0.1s ease-out;
    -moz-transition: all 0.1s ease-out;
    -o-transition: all 0.1s ease-out;
    -webkit-transition: all 0.1s ease-out;
}

.noAnimations {
    transition: none !important;
    -webkit-transition: none !important;
    -moz-transition: none !important;
    -o-transition: none !important;
    -ms-transition: none !important;
}]]></CSP>


<CSP name="WebTerminal/css/terminal.css" application="/csp/sys/" default="1"><![CDATA[
.terminal-base {
    position: relative;
}

terminal-base tr, td {
    padding: 0 6px 6px 6px;
    margin: 0;
    border: 0;
    border-spacing: 0;
}

.terminal-output-block {
    position: relative;
    overflow: hidden;
    display: block;
}

.terminal-inputContainer {
    position: relative;
    overflow: hidden;
}

.terminal-outputContainer {
    position: relative;
    overflow: hidden;
}

.terminal-message-body {
    position: relative;
    overflow: hidden;
}

.terminal-output-body {
    white-space: pre;
    word-wrap: break-word;
}

.terminal-message-head {
    display: inline-block;
    float: left;
}

.terminal-message-head:after {
    content: " >";
    margin-right: 10px;
}

.terminal-input-visible {
    min-height: 1em;
    white-space: pre;
    word-wrap: break-word;
}

/* fix white-space when \n is last */
.terminal-input-visible:after {
    content: " ";
}

/* textarea block */
.terminal-input-hidden {
    position: absolute;
    top: 0;
    left: 0;
    display: block;
    width: 100%;
    height: 100%;
    padding: 0;
    margin: 0;
    border: none;
    outline: none;
    text-decoration: none;
    overflow: hidden;
    background: none;
    font: inherit;
    color: rgba(0,0,0,0);
    resize: none;
    word-wrap: break-word;
    white-space: pre;
}

.terminal-suggestion {
    color: gray;
}

/* control panel */

#terminal-control-panel {
    position: fixed;
    left: -100%;
    top: 0;
    width: 100%;
    height: 100%;
    z-index: 1000;
    background: rgba(40,40,40,0.95);
    color: white;

    transition: left 0.2s ease;
    -webkit-transition: left 0.2s ease;
    -o-transition: left 0.2s ease;
    -moz-transition: left 0.2s ease;
}

.terminal-control-content {
    position: relative;
    margin: 20px;
}

#terminal-control-table {
    width: 100%;
}

#terminal-control-table > tbody > tr > td:first-child {
    color: #dadada;
    font-size: 1.3em;
    font-weight: 900;
    padding-right: 20px;
    white-space: nowrap;
    padding-bottom: 20px;
}

#terminal-control-table > tbody > tr:first-child {
    height: 50px;
}

#terminal-control-table > tbody > tr > td:last-child {
    padding: 0;
    vertical-align: top;
}

#terminal-control-closeButton {
    float: right;
    cursor: pointer;
}]]></CSP>


<CSP name="WebTerminal/css/theme-default.css" application="/csp/sys/" default="1"><![CDATA[
.syntax-_digit { color: #00ff89; } /* 6006 */
.syntax-_symbol { color: #82fffa; } /* +*-/=,!_'#?\ */
.syntax-_bracket { color: #82fffa; } /* {}[]() */
.syntax-_string { color: #26e500; } /* "test" */
.syntax-_function { color: #9291ff; } /* $LENGTH */
.syntax-_userFunction { color: #cea3ff; } /* $$MY */
.syntax-_macro { color: #cb64ff; } /* $$$test */
.syntax-_sysMacro { color: #ff00fe; } /* ##test */
.syntax-_classProp { color: #0091ff; } /* ..test */
.syntax-_global { color: #ff5156; } /* ^test */
.syntax-_command { color: #29cfe9 } /* set WRITE kill */
.syntax-_client { color: #e2dc00; } /* /help /define /siege */
.syntax-_other { color: #82fffa; } /* unrecognised */
.syntax-_comment { color: #808080 } /*  */

.warning { color: #ffa500 }
.hint { color: #84C200 }
.error { color: #ff0000 }
.info { color: #fffd7c }
.executed { color: #34ff00 }
.complete { color: #a9ff30 }]]></CSP>


<CSP name="WebTerminal/css/theme-monokai.css" application="/csp/sys/" default="1"><![CDATA[
.syntax-_digit { color: #7FB347 }
.syntax-_symbol { color: #D8D8D8 }
.syntax-_bracket { color: #D8D8D8 }
.syntax-_string { color: #E6DB74 }
.syntax-_function { color: #BED6FF }
.syntax-_userFunction { color: #BED6FF }
.syntax-_macro { color: #66D9EF }
.syntax-_sysMacro { color: #EFC090 }
.syntax-_classProp { color: #0091ff }
.syntax-_global { color: #D25252 }
.syntax-_command { color: #66CCB3 }
.syntax-_client { color: #D9E577 }
.syntax-_other { color: #BFA4A4 }
.syntax-_comment { color: #75715e }

.warning { color: #EFB571 }
.hint { color: #CCDF32 }
.error { color: #D25252 }
.info { color: #D9E577 }
.executed { color: #D9E577 }
.complete { color: #5eb364 }

body { background: #272822; color: #F8F8F2 }]]></CSP>


<CSP name="WebTerminal/css/theme-studio.css" application="/csp/sys/" default="1"><![CDATA[
.syntax-_digit { color: #000000; }
.syntax-_symbol { color: #000000; }
.syntax-_bracket { color: #000000; }
.syntax-_string { color: #008000; }
.syntax-_function { color: #0000ff; }
.syntax-_userFunction { color: #0000ff; }
.syntax-_macro { color: #0000ff; }
.syntax-_sysMacro { color: #0000ff; }
.syntax-_classProp { color: #0000ff; }
.syntax-_global { color: #000000; }
.syntax-_command { color: #0000ff }
.syntax-_client { color: #404fff; }
.syntax-_other { color: #000000; }
.syntax-_comment { color: #008000 }

.warning { color: #a56800 }
.hint { color: #127a00 }
.error { color: #ff0000 }
.info { color: #00008B }
.executed { color: #127a00 }
.complete { color: #127a00 }

body { background: white; color: black }]]></CSP>


<CSPBase64 name="WebTerminal/favicon.ico" application="/csp/sys/" default="1">
AAABAAEAEBAAAAAAAABoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAAAQAAAAAAAAAAAAAAAAA
AAAAAAD///8BAAAABQAAABEAAAAJAAAAAwAAAAMAAAAD////Af///wH///8B////Af///wH///8B
////Af///wH///8B////AQAAAAcAAAAVLyoiXzcxJa09NijfPjcp4YiHhcWbm5ypioqLhWtrbF8v
Ly85AAAAIQAAAAP///8B////AXt7fBGFhYZHiomLRXFua0FEPzNPOjMkY1dSSceqqqr/vLy9/7a2
t/+vr7D/kZGS4wAAABkAAAAbAAAAFf///wGXlZKPq6qg57GtlK2vqIqjsaySt6+qlcOvr5/1t7es
/76+t//GxsT/zMzM98fIyIW8vLxDwcHBKY6Njg////8BioZ8j5aTjpkUERGjHRIS4SIVFM8oGRa9
Mh8ZrUc0KatfTT2tdWROsYZ1XauciHGVt6aQl7uwnp/GxLPRuLi2gYyIfo+XlJCZCQgIzQAAAP8A
AAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8IBgX/Eg8O5bOwpXuOi4CPmZaSmQgI
B80AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wICAfGqqKB3kY2C
j5yZlJkIBwfNAAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8FBATt
paKcd5SQhY+em5eZCAcHzQAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wUFBf8a
Ghr/Li0s65+dl3WXk4iPop+amQgHB80AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AQEB/xIS
Ev8mJib/MjIy/zk3NumamJJ1m5eMj6WinZkHBwfPXV1d/wcHB/9PT0//V1dX/0tLS/8AAAD/BQUF
/xkZGf8nJyf/MjIy/zw8PP9CPz3nlJKNdZ+bj5GopZ+ZBwcHz25ubv+qqqr/ODg4/zg4OP8pKSn/
CAgI/xwcHP8oKCj/MzMz/zw8PP9DQ0P/SENB55COiXOin5KRq6iimQcHBs9gYGD/m5ub/wAAAP8A
AAD/DQ0N/x0dHf8oKCj/MzMz/z09Pf9DQ0P/R0dH/0pFQ+WMioVzpaGUkaunoZ8ICAjPc3Nz/wcH
B/0GBgb1FBMT7x4eHecqKSfhNTMx3T89OttIRUHZT0xH2VVSTNtwbWTflZOQibKwrYe4tanplpGC
s4uDcamblIOto52Ot6Gcj7+fmo69nZmNs5qWi6mVkombjoyFjYaFgH9/f3xxfXx9Y3t8fi+npqYb
sbKyU7m4uE2/v787srKxKY+OjxdtbW0H////Af///wH///8B////Af///wH///8B////Af///wH/
//8B//8AAPA/AAD8DwAAAA8AAAAAAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAAA
AAAADwAA//8AAA==
</CSPBase64>


<CSPBase64 name="WebTerminal/img/back.png" application="/csp/sys/" default="1">
iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAB
NmlDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjarY6xSsNQFEDPi6LiUCsEcXB4kygotupgxqQt
RRCs1SHJ1qShSmkSXl7VfoSjWwcXd7/AyVFwUPwC/0Bx6uAQIYODCJ7p3MPlcsGo2HWnYZRhEGvV
bjrS9Xw5+8QMUwDQCbPUbrUOAOIkjvjB5ysC4HnTrjsN/sZ8mCoNTIDtbpSFICpA/0KnGsQYMIN+
qkHcAaY6addAPAClXu4vQCnI/Q0oKdfzQXwAZs/1fDDmADPIfQUwdXSpAWpJOlJnvVMtq5ZlSbub
BJE8HmU6GmRyPw4TlSaqo6MukP8HwGK+2G46cq1qWXvr/DOu58vc3o8QgFh6LFpBOFTn3yqMnd/n
4sZ4GQ5vYXpStN0ruNmAheuirVahvAX34y/Axk/96FpPYgAAACBjSFJNAAB6JQAAgIMAAPn/AACA
6AAAUggAARVYAAA6lwAAF2/XWh+QAAAAGElEQVR42mJQVlJkQAZQPoQCAAAA//8DABISATPXp3mc
AAAAAElFTkSuQmCC
</CSPBase64>


<CSP name="WebTerminal/index.csp" application="/csp/sys/" default="1"><![CDATA[
<!DOCTYPE html>

<html>

    <head>
        <title id="lang-field-15">Caché WEB Terminal</title>
        <meta charset="utf-8">
        <meta name="author" content="ZitRo - InterSystems">
        <meta name="Description" content="Web-based terminal for Cache administration.">
        <meta name="keywords" content="Cache,Caché,terminal,web,web-based,remote,control,Caché WebTerminal">
        <link href="favicon.ico" rel="shortcut icon" type="image/x-icon"/>
        <link rel="stylesheet" href="css/base.css">
        <link rel="stylesheet" href="css/terminal.css">
        <link rel="stylesheet" href="css/extra.css">
        <link rel="stylesheet" href="css/theme-default.css" id="terminal-color-theme">
        <script type="text/javascript" src="js/storage.js"></script> <!-- first loading storage independent module -->
        <script type="text/javascript" src="js/parser.js"></script> <!-- parser is independent module -->
        <script type="text/javascript" src="js/hid.js"></script> <!-- hid is independent module -->
        <script type="text/javascript" src="js/language.js"></script> <!-- language module reads setting from storage -->
        <script type="text/javascript" src="js/base.js"></script> <!-- dom/settings uses storage, parser and language -->
        <script type="text/javascript" src="js/application.js"></script> <!-- application module uses language, settings, storage -->
        <script type="text/javascript" src="js/server.js"></script> <!-- server uses parser -->
        <script type="text/javascript" src="js/terminal.js"></script> <!-- terminal uses almost all modules above -->
        <script type="text/javascript" src="js/unit.js"></script> <!-- unit-test module, not necessary -->
    </head>

    <body>
        <div id="terminal-control-panel">
            <div class="terminal-control-content">
                <span id="terminal-control-closeButton" class="info"><span id="lang-field-0"></span></span>
                <h1 id="lang-field-1"></h1>
                <table id="terminal-control-table">
                    <tbody>
                        <tr>
                            <td class="center" colspan="2" id="lang-field-2"></td>
                        </tr>
                        <tr>
                            <td>
                                <input id="settings-highlighting" type="checkbox">
                                <label for="settings-highlighting" id="lang-field-3">

                                </label>
                            </td>
                            <td id="lang-field-4">

                            </td>
                        </tr>
                        <tr>
                            <td>
                                <input id="settings-parse-output" type="checkbox">
                                <label for="settings-parse-output" id="lang-field-5">

                                </label>
                            </td>
                            <td id="lang-field-6">

                            </td>
                        </tr>
                        <tr>
                            <td>
                                <input id="settings-cleanStartup" type="checkbox">
                                <label for="settings-cleanStartup" id="lang-field-7">

                                </label>
                            </td>
                            <td id="lang-field-8">

                            </td>
                        </tr>
                        <tr>
                            <td>
                                <input id="settings-animations" type="checkbox">
                                <label for="settings-animations" id="lang-field-9">

                                </label>
                            </td>
                            <td id="lang-field-10">

                            </td>
                        </tr>
                        <tr>
                            <td>
                                <input id="settings-autosaving" type="checkbox">
                                <label for="settings-autosaving" id="lang-field-11">

                                </label>
                            </td>
                            <td id="lang-field-12">

                            </td>
                        </tr>
                        <tr>
                            <td id="lang-field-13">

                            </td>
                            <td>
                                <label id="terminal-languages-container">

                                </label>
                            </td>
                        </tr>
                        <tr>
                            <td id="lang-field-14">

                            </td>
                            <td>
                                <label id="terminal-themes-container">

                                </label>
                            </td>
                        </tr>
                    </tbody>
                </table>
            </div>
        </div>
        <div class="terminal-base" id="terminal">
            <div class="terminal-output-block" id="terminal-output">
                <!-- output -->
            </div>
            <div class="terminal-inputContainer">
                <div class="terminal-message-head" id="terminal-namespace">
                    <!-- namespace -->
                </div>
                <div class="terminal-message-body">
                    <div class="terminal-input-visible" id="terminal-inputView">
                        <!-- highlighted input -->
                    </div>
                    <textarea class="terminal-input-hidden" id="terminal-hiddenInput">
                    	<!-- normal input -->
                    </textarea>
                </div>
            </div>
        </div>
        <script type="text/javascript" id="startup">
            try {
                application.authorizationKey = "#(%session.CSPSessionCookie)#";
                application.initialize();
            } catch (e) {
                alert("Unable to initialize terminal: check console output.");
                console.log(e)
            }
        </script>
    </body>

</html>]]></CSP>


<CSP name="WebTerminal/js/application.js" application="/csp/sys/" default="1"><![CDATA[
/**
 * Basic application object.
 */
var application = new function() {

    var version = "0.9.9.5 beta"; // link to language.js
    this.debug = false; // remove for release
    this.debugUrlPart = "172.27.25.133:57772"; // in-debug mode

    this.browser = "gc";
    this.authorizationKey = "";

    /**
     * How to make your own theme for this terminal application? Easier then ever!
     *
     * 1. Add theme name to the list below;
     * 2. Make CSS theme file like theme-default.css;
     * 3. Place this file to /css/ directory and name it "theme-<name_of_your_theme>.css";
     * 4. Check theme in settings and use it!
     *
     * We're waiting for your cool themes ;)
     *
     * @type {{number}}
     */
    this.themes = { // here you can insert theme name, but do not forget to add appropriate theme file.
        "default": 0,
        "studio": 0,
        "monokai": 0
    };

    this.version = function() { return version };

    this.HELPBOX = lang.get(49);

    var tips = 8, currentTip = 0; // number of tips
    var getTip = function(no, all) {
        var s;
        switch (no){
            case 0: s = lang.get(50); break;
            case 1: s = lang.get(51); break;
            case 2: s = lang.get(52); break;
            case 3: s = lang.get(53); break;
            case 4: s = lang.get(54); break;
            case 5: s = lang.get(55); break;
            case 6: s = lang.get(56); break;
            default: s = lang.get(57);
        }
        if (!all) {
            if (no === 0) s += lang.get(58);
            else if (no === 1) s += lang.get(59);
            else if (no === 2) s += lang.get(60);
        }
        return s;
    };

    this.getTips = function(all) {
        var s = "<div class=\"normalWrap\">";

        if (all) {
            for (var i = 0; i < tips; i++) {
                s += getTip(i, all);
            }
        } else {
            s += getTip(currentTip++, all);
            currentTip = currentTip % tips;
        }

        return s + "</div>";
    };

    var detectBrowser = function() {
        var app = navigator.appName.toLowerCase(), b = "gc";
        switch (app) {
            case "microsoft internet explorer": b = "ie"; break;
            case "google chrome": b = "gc"; break;
            case "mozilla firefox": b = "mf"; break;
            case "netscape": b = "ns"; break;
            default: log.write("unrecognised browser: " + app);
        }
        application.browser = b;
    };

    this.initialize = function() {
        detectBrowser();
        terminal.initialize();
    };

};]]></CSP>


<CSP name="WebTerminal/js/base.js" application="/csp/sys/" default="1"><![CDATA[
/**
 * Script includes dom representation object, log object and basic prototypes.
 */

String.prototype.splice = function(position, length, string) {
    return (this.slice(0,position) + string + this.slice(position + Math.abs(length)));
};

function Clone(source) {
    for (var i in source) {
        if (!source.hasOwnProperty(i)) continue;
        if (typeof source[i] == 'source') {
            this[i] = new Clone(source[i]);
        }
        else{
            this[i] = source[i];
        }
    }
}

Object.prototype.merge = function(object) {

    var combine = function(target,object) {

        for (var property in object) {

            if (!object.hasOwnProperty(property)) continue;
            if (typeof object[property] != "object") {
                target[property] = object[property];
            } else {
                target[property] = new Clone(object[property]);
            }

        }

    };

    combine(this,object);

};

var log = new function() {
    this.write = function() {
        (window.console && console.log)?console.log.apply(console, arguments):alert(arguments.join(", "));
    }
};

/**
 * This object represents every dom element needed for terminal application and includes methods to work with graphical
 * part of web terminal. See [objects] property for more information.
 */
var dom = new function() {

    var isDomElement = function(object) {
        return (
            typeof HTMLElement === "object" ? object instanceof HTMLElement: //DOM2
                object && typeof object === "object" && object !== null && object.nodeType === 1 &&
                    typeof object.nodeName === "string"
            );
    };

    /**
     * DOM objects to work with.
     *
     * @type {object}
     */
    this.objects = {
        namespace: null, // current namespace holder
        input: null, // input object (hidden input, main user-accessible input)
        output: null, // terminal output
        inputView: null, // input view (highlighted syntax)
        panel: null,
        terminal: null,
        panelTable: null,
        closePanelButton: null,
        settingsHighlighting: null,
        settingsAnimations: null,
        settingsAutoSaving: null,
        settingsCleanStartup: null,
        settingsParseOutput: null,
        themeCSS: null,
        themesContainer: null,
        languagesContainer: null,
        body: null,
        startupScript: null,

        getCaretPosition: function(object) {
            object.focus();
            if(object.selectionStart) return object.selectionStart;
            else if(!document.selection) return 0;
            var c = "\001";
            var sel	= document.selection.createRange();
            var dul	= sel.duplicate();
            dul.moveToElementText(object);
            sel.text = c;
            var len = dul.text.indexOf(c);
            sel.moveStart("character", -1);
            sel.text = "";
            return len;
        },
        
        getThemeSelectorObject: function(themeName) {
            return dom.element("terminal-color-theme-" + themeName);
        },

        getLanguageSelectorObject: function(langName) {
            return dom.element("terminal-language-unit-" + langName);
        }
    };

    /**
     * Adds class to object.
     *
     * @param object
     * @param className
     */
    this.addClass = function(object, className) {
        if (isDomElement(object)) {
            object.className += className;
        } else log.write("Can't add class to non-DOM element.");
    };

    /**
     * Removes class from object.
     *
     * @param object
     * @param className
     */
    this.removeClass = function(object, className) {
        if (isDomElement(object)) {
            var regExp = new RegExp("(?:^|\\s)" + className + "(?!\\S)","g");
            object.className = object.className.replace(regExp,"");
        } else log.write("Can't remove class from non-DOM element.");
    };

    /**
     * Clear all logs before.
     */
    this.clearLogs = function() {
        this.objects.output.innerHTML = "";
    };

    /**
     * Scrolls to the bottom of the page.
     */
    this.scrollBottom = function() {
        try {
            var h = document.body.scrollHeight;
            if (dom.objects.terminal.scrollHeight + 40 < h) return;
            document.body.scrollTop = document.body.scrollHeight;
            window.scrollTo(0, document.body.scrollHeight);
        } catch (e) {

        }
    };

    /**
     * Returns true while input element in dom under focus.
     *
     * @returns {boolean}
     */
    this.focused = function(object) {
        return (document.activeElement == object);
    };

    this.performForClassObjects = function(className,handler) {
        var classes = document.getElementsByClassName(className);
        for (var i = 0; i < classes.length; i++) {
            handler.call(classes[i])
        }
    };

    /**
     * Gets focused object in dom.
     *
     * @returns {DocumentView}
     */
    this.getFocusedObject = function() {
        return document.activeElement;
    };

    /**
     * Returns element by ID.
     *
     * @param name
     * @returns {HTMLElement}
     */
    this.element = function(name) {
        return document.getElementById(name)
    };

    // definition of all required objects for terminal application in DOM
    var defineObjects = function(objects) {
        objects.namespace = dom.element("terminal-namespace");
        objects.input = dom.element("terminal-hiddenInput");
        objects.output = dom.element("terminal-output");
        objects.inputView = dom.element("terminal-inputView");
        objects.terminal = dom.element("terminal");
        objects.panel = dom.element("terminal-control-panel");
        objects.panelTable = dom.element("terminal-control-table");
        objects.closePanelButton = dom.element("terminal-control-closeButton");
        objects.settingsHighlighting = dom.element("settings-highlighting");
        objects.themeCSS = dom.element("terminal-color-theme");
        objects.settingsAnimations = dom.element("settings-animations");
        objects.settingsAutoSaving = dom.element("settings-autosaving");
        objects.settingsCleanStartup = dom.element("settings-cleanStartup");
        objects.themesContainer = dom.element("terminal-themes-container");
        objects.settingsParseOutput = dom.element("settings-parse-output");
        objects.languagesContainer = dom.element("terminal-languages-container");
        objects.startupScript = dom.element("startup");
        objects.body = document.body;
    };


    /**
     * Checks if every object defined in objects.
     *
     * @returns {boolean}
     *  Ready to work with terminal DOM.
     */
    this.objectsReady = function() {
        for (var object in this.objects) {
            if (!this.objects.hasOwnProperty(object) || typeof this.objects[object] != "object") continue;
            if (this.objects[object] == null) {
                log.write("DOM object " + object + " not found!");
                return false;
            }
        }
        return true;
    };

    /**
     * Initialize objects data.
     *
     * @returns {boolean}
     */
    this.initialize = function() {
        defineObjects.call(this,this.objects);

        for (var theme in application.themes) {
            if (!application.themes.hasOwnProperty(theme) || !theme) continue;
            this.objects.themesContainer.innerHTML += "<input id=\"terminal-color-theme-" + theme + "\" " +
                "type=\"radio\" name=\"terminal-color-scheme\" value=\"" + theme + "\">" + theme[0].toUpperCase() +
                theme.substr(1);
        }

        for (var l in lang.availableLanguages) {
            if (!lang.availableLanguages.hasOwnProperty(l) || !l) continue;
            this.objects.languagesContainer.innerHTML += "<input id=\"terminal-language-unit-" + l + "\" " +
                "type=\"radio\" name=\"terminal-language-unit\" value=\"" + l + "\">" + l.toUpperCase();
        }

        return this.objectsReady();
    };

    /**
     * Removes element from DOM.
     *
     * @param object
     *  DOM element to remove.
     * @returns {Node}
     *  Removed node or null, if object is not in DOM or not DOM object.
     */
    this.remove = function(object) {
        return (isDomElement(object))?object.parentNode.removeChild(object):null;
    };

};

/**
 * This object represents whole terminal panel functionality.
 */
var settings = new function() {

    var animations = true,
        highlighting = true,
        colorTheme = "default",
        restoreSession = 0,
        parseOutput = 0,
        cleanStartup = 0,
        language = "en";

    this.get_restoreSession = function() { return restoreSession == 1 };
    this.get_cleanStartup = function() { return cleanStartup == 1 && !terminal.ready };
    this.get_parseOutput = function() { return parseOutput };
    this.get_animations = function() { return animations };
    this.get_language = function() { return language };
    this.get_theme = function() { return colorTheme };

    this.export = function() {
        return {
            "!export:settings": true,
            animations: animations,
            highlighting: highlighting,
            colorTheme: colorTheme,
            restoreSession: restoreSession,
            cleanStartup: cleanStartup,
            parseOutput: parseOutput,
            language: language
        };
    };

    this.import = function(settingImportObject) {
        if (!(typeof settingImportObject === "object" && settingImportObject.hasOwnProperty("!export:settings") &&
            settingImportObject.hasOwnProperty("animations") && settingImportObject.hasOwnProperty("highlighting") &&
            settingImportObject.hasOwnProperty("colorTheme") && settingImportObject.hasOwnProperty("restoreSession") &&
            settingImportObject.hasOwnProperty("cleanStartup") && settingImportObject.hasOwnProperty("parseOutput") &&
            settingImportObject.hasOwnProperty("language"))) {
            log.write("Wrong settings object to import. Use /reset to restore settings.");
            return;
        }
        animations = settingImportObject["animations"];
        highlighting = settingImportObject["highlighting"];
        colorTheme = settingImportObject["colorTheme"];
        parseOutput = settingImportObject["parseOutput"];
        restoreSession = (settingImportObject["restoreSession"] == 1)?1:0;
        cleanStartup = settingImportObject["cleanStartup"];
        language = settingImportObject["language"];
        this.update();
    };

    this.reset = function() {
        animations = true;
        highlighting = true;
        colorTheme = "default";
        restoreSession = 0;
        parseOutput = 0;
        cleanStartup = 0;
        language = "en";
        this.update();
    };

    /**
     * Updates terminal settings according to dom checked boxes.
     */
    this.updateFromView = function() {

        highlighting = dom.objects.settingsHighlighting.checked;
        animations = dom.objects.settingsAnimations.checked;
        restoreSession = (dom.objects.settingsAutoSaving.checked)?1:0;
        cleanStartup = (dom.objects.settingsCleanStartup.checked)?1:0;
        parseOutput =(dom.objects.settingsParseOutput.checked)?1:0;

        colorTheme = "default";
        for (var theme in application.themes) {
            if (!application.themes.hasOwnProperty(theme)) continue;
            var obj = dom.objects.getThemeSelectorObject(theme);
            if (!obj) continue;
            if (obj.checked) colorTheme = theme;
        }

        language = "en";
        for (var l in lang.availableLanguages) {
            if (!lang.availableLanguages.hasOwnProperty(l)) continue;
            var obj2 = dom.objects.getLanguageSelectorObject(l);
            if (!obj2) continue;
            if (obj2.checked) language = l;
        }

        dom.objects.themeCSS.href = "css/theme-" + colorTheme + ".css";
        if (!animations) {
            dom.removeClass(dom.objects.body,"noAnimations");
            dom.addClass(dom.objects.body,"noAnimations");
        } else dom.removeClass(dom.objects.body,"noAnimations");

        storage.set("settings", settings.export());

    };

    /**
     * Returns true if output needs to be highlighted.
     *
     * @returns {boolean}
     */
    this.highlightOutput = function() {
        return highlighting;
    };

    /**
     * Closes panel.
     */
    this.closePanel = function() {
        dom.objects.panel.style.left = "-100%";
    };

    /**
     * Closes panel.
     */
    this.openPanel = function() {
        dom.objects.panel.style.left = "0";
    };

    /**
     * Updates terminal settings view on dom.
     */
    this.updateFromModel = function() {
        dom.objects.settingsHighlighting.checked = highlighting;
        dom.objects.settingsAnimations.checked = animations;
        dom.objects.settingsParseOutput.checked = parseOutput;
        dom.objects.settingsAutoSaving.checked = restoreSession == 1;
        dom.objects.settingsCleanStartup.checked = cleanStartup == 1;
        for (var theme in application.themes) {
            if (!application.themes.hasOwnProperty(theme)) continue;
            var obj = dom.objects.getThemeSelectorObject(theme);
            if (!obj) continue;
            obj.checked = colorTheme === theme;
        }
        for (var l in lang.availableLanguages) {
            if (!lang.availableLanguages.hasOwnProperty(l)) continue;
            var obj2 = dom.objects.getLanguageSelectorObject(l);
            if (!obj2) continue;
            obj2.checked = language === l;
        }
    };

    this.update = function() {
        this.updateFromModel();
        this.updateFromView();
    };

    /**
     * Applies language to the document.
     */
    function translateDocument() {
        var i = 0, e;
        while (e = dom.element("lang-field-" + i)) {
            e.innerHTML = lang.get(62 + i);
            i++;
        }
    }

    /**
     * Initializes settings. Returns true if initialization successful.
     *
     * @returns {boolean}
     */
    this.initialize = function() {
        dom.objects.panel.style.left = "-100%";
        var sets = storage.get("settings");
        if (sets) this.import(sets);
        if (restoreSession) terminal.loadState();
        hid.bindClick(dom.objects.panelTable,this.updateFromView);
        this.update();
        hid.bindClick(dom.objects.closePanelButton, function() { settings.closePanel() });
        hid.bindClick(dom.objects.languagesContainer,function(){
            var ih = this.hasAttribute("duck");
            if (!ih) {
                this.setAttribute("duck", "quack!");
                var s = document.createElement("span");
                s.innerHTML = " " + lang.get(61);
                this.appendChild(s);
            }
        });
        translateDocument();
        return true;
    }

};]]></CSP>


<CSP name="WebTerminal/js/hid.js" application="/csp/sys/" default="1"><![CDATA[
// represents actions for human input device
var hid = new function() {

    var keyState = [],
        mouseState = 0;

    /**
     * Definitions of functional keys. Warning: do not add non-functional keys here.
     *
     * @type {number}
     */
    this.keys = {
        CTRL: 17,
        SHIFT: 16,
        ALT: 18,
        TAB: 9,
        ENTER: 13,
        BACKSPACE: 8,
        UP: 38,
        DOWN: 40,
        ESC: 27
    };

    var bindEvent = function(object, event, handler) {

        if(object.addEventListener) {
            object.addEventListener(event,handler,false);
        } else if(object.attachEvent) {
            object.attachEvent(event,handler);
        }

    };

    /**
     * Function prevents browser default action for event.
     *
     * @param event {event}
     */
    this.preventDefault = function(event) {
        if (event && event.preventDefault) {
            event.stopPropagation();
            event.preventDefault();
        } else {
            window.event.cancelBubble = true; // IE
        }
    };

    /**
     * Returns if key is functional key defined in hid.keys
     *
     * @param key
     * @returns {boolean}
     */
    this.functional = function(key) {
        for (var k in this.keys) {
            if (!this.keys.hasOwnProperty(k)) continue;
            if (this.keys[k] == key) return true;
        }
        return false;
    };

    /**
     * Returns true if key currently pressed.
     *
     * @param keyCode
     *  Char code of key.
     * @returns {boolean}
     */
    this.keyPressed = function(keyCode) {
        return (keyState[keyCode])?true:false;
    };

    /**
     * Returns true if mouse currently pressed.
     *
     * @returns {boolean}
     */
    this.mousePressed = function() {
        return (mouseState)?true:false;
    };

    /**
     * Bind key down. Note that this will happen only once.
     *
     * @param object
     *  Object to bind to.
     * @param handler
     *  Function to call with event argument.
     */
    this.bindKeyDown = function(object,handler) {
        bindEvent(object,"keydown",handler);
    };

    /**
     * Bind key press. This will happen every time key triggered.
     *
     * @param object
     *  Object to bind to.
     * @param handler
     *  Function to call with event argument.
     */
    this.bindKeyPress = function(object,handler) {
        bindEvent(object,"keypress",handler);
    };

    /**
     * Bind key up. This will happen once key released.
     *
     * @param object
     *  Object to bind to.
     * @param handler
     *  Function to call with event argument.
     */
    this.bindKeyUp = function(object,handler) {
        bindEvent(object,"keyup",handler);
    };

    /**
     * Bind click event on object.
     *
     * @param object
     *  Object to bind to.
     * @param handler
     *  Function to call with event argument.
     */
    this.bindClick = function(object,handler) {
        bindEvent(object,"click",handler);
    };

    /**
     * Bind mouse down event on object.
     *
     * @param object
     *  Object to bind to.
     * @param handler
     *  Function to call with event argument.
     */
    this.bindMouseDown = function(object,handler) {
        bindEvent(object,"mousedown",handler);
    };

    /**
     * Bind mouse up event on object.
     *
     * @param object
     *  Object to bind to.
     * @param handler
     *  Function to call with event argument.
     */
    this.bindMouseUp = function(object,handler) {
        bindEvent(object,"mouseup",handler);
    };

    // initialize global key states
    for (var i = 0; i < 256; i++) keyState[i] = 0;
    this.bindKeyDown(document, function(event) { keyState[event.keyCode] = 1 });
    this.bindKeyUp(document, function(event) { keyState[event.keyCode] = 0 });
    this.bindMouseDown(document, function() { mouseState = 1 });
    this.bindMouseUp(document, function() { mouseState = 0 });

};
]]></CSP>


<CSP name="WebTerminal/js/language.js" application="/csp/sys/" default="1"><![CDATA[
/**
 * This global object holds language constants for whole terminal application.
 *
 * Required objects:
 *  parser
 */
var lang = new function() {

    /**
     * List of available languages in settings. To add language translation perform the next:
     *
     * 1. Add language sign to the list below;
     * 2. Fill language.js -> languageBase variable according to examples there;
     * 3. Use it!
     *
     * Do not forget to check that all language units are filled. In case of nonexistent language unit you will receive
     * warning text instead of expected phrase.
     */
    this.availableLanguages = {
        "en": 0,
        "ru": 0
    };
    var currentLanguage = "en", languages = this.availableLanguages;

    var c = {
            0: parser.highlightHTML("/help"),
            1: parser.highlightHTML("/tip"),
            2: parser.highlightHTML("/connect"),
            3: "0.9.9.5 beta",
            4: 1,
            5: parser.highlightHTML("set test = 12"),
            6: parser.highlightHTML("write test"),
            7: parser.highlightHTML("/reset"),
            8: parser.highlightHTML("/settings")
        };

    /**
     * Global language object. May include some dynamic data, but it will be performed once at the beginning, for
     * example, to highlight some pieces
     */
    var languageBase = {
        0: {
            en: "Terminal base ready. Type " + c[0] + " or " + c[1] + " to get more information.",
            ru: "Приложение терминала готово. Введите " + c[0] + " или " + c[1] + " чтобы получить дополнительную информацию."
        },
        1: {
            en: "Connecting to",
            ru: "Подключение к"
        },
        2: {
            en: "Terminal state has been loaded.",
            ru: "Состояние терминала загружено."
        },
        3: {
            en: "Authorisation succeeded.",
            ru: "Авторизация успешна."
        },
        4: {
            en: "system",
            ru: "система"
        },
        5: {
            en: "Authorisation failed.",
            ru: "Авторизация не удалась."
        },
        6: {
            en: "Terminal state has been saved.",
            ru: "Состояние терминала сохранено."
        },
        7: {
            en: "Unable to load terminal state: no saves.",
            ru: "Невозможно загрузить состояние терминала: нет сохранений."
        },
        8: {
            en: "Saving terminal state...",
            ru: "Сохранение состояния терминала..."
        },
        9: {
            en: "Unknown terminal mode",
            ru: "Неизвестный режим терминала"
        },
        10: {
            en: "Data received",
            ru: "Полученные данные"
        },
        11: {
            en: "SQL mode",
            ru: "режим SQL"
        },
        12: {
            en: "enabled",
            ru: "активирован"
        },
        13: {
            en: "disabled",
            ru: "деактивирован"
        },
        15: {
            en: "Reload the page to connect to server again.",
            ru: "Перезагрузите страницу, чтобы вновь присоединиться к серверу."
        },
        16: {
            en: "Use",
            ru: "Используйте"
        },
        17: {
            en: "defined as",
            ru: "определено как"
        },
        18: {
            en: "for",
            ru: "для"
        },
        19: {
            en: "In development since summer, 2013",
            ru: "В разработке с лета, 2013"
        },
        20: {
            en: "Project page",
            ru: "Страница проекта"
        },
        21: {
            en: "Use at your own risk!",
            ru: "Используйте на свой страх и риск!"
        },
        22: {
            en: "For the time being",
            ru: "Пока что"
        },
        23: {
            en: "Query client execution time",
            ru: "Время выполнения команды"
        },
        24: {
            en: "Packages",
            ru: "Пакетов"
        },
        25: {
            en: "current/ideal",
            ru: "текущее/идеальное"
        },
        26: {
            en: "Please, enter watch name. Use " + c[0] + " for more information.",
            ru: "Введите цель слежения. Введите " + c[0] + " чтобы получить больше информации."
        },
        27: {
            en: "Enter command or index.",
            ru: "Введите команду или индекс."
        },
        28: {
            en: "Command saved to slot",
            ru: "Комманда сохранена в слот"
        },
        29: {
            en: "Choose correct slot: slots 0-9 are available",
            ru: "Выберите существующий слот: слоты 0-9 доступны"
        },
        30: {
            en: "I'm alive!",
            ru: "Я жив!"
        },
        31: {
            en: "Unknown internal command",
            ru: "Неизвестная внутренняя команда"
        },
        32: {
            en: "Watches stopped.",
            ru: "Слежение остановлено."
        },
        33: {
            en: "Unable to watch",
            ru: "Невозможно следить за"
        },
        34: {
            en: "Stopping to watch",
            ru: "Прекращаем слежение за"
        },
        35: {
            en: "Starting to watch",
            ru: "Начинаем слежение за"
        },
        36: {
            en: "Disconnecting from current server...",
            ru: "Закрывается соединение с сервером..."
        },
        37: {
            en: "Pointless server disconnection: there's no connection established.",
            ru: "Бесполезное закрытие соединения с сервером: его и так нет."
        },
        38: {
            en: "Loading Caché language for",
            ru: "Загрузка словаря Caché для"
        },
        39: {
            en: "Wrong language file for",
            ru: "Неверный файл словаря для"
        },
        40: { // means "terminal language" object
            en: "Language for",
            ru: "Словарь для"
        },
        41: {
            en: "merged with current.",
            ru: "слит с текущим."
        },
        42: {
            en: "load fail.",
            ru: "не удалось загрузить."
        },
        43: {
            en: "Connection already established. Disconnect first.",
            ru: "Соединение уже установленно. Закройте его сперва."
        },
        44: {
            en: "No connection established. Try "+c[2]+" first.",
            ru: "Соединение отсутствует. Установите его, используя "+c[2]
        },
        45: {
            en: "Connection terminated: code",
            ru: "Соединение потеряно: код"
        },
        46: {
            en: "WebSocket error:",
            ru: "Ошибка WebSocket:"
        },
        47: {
            en: "Can't save data to storage: no more space available. Expand storage place and try again.",
            ru: "Незьзя сохранить данные в локальное хранилище: нет места. Измените настройки хранилища и попробуйте еще раз."
        },
        48: {
            en: "Local HTML5 storage is not available. Saving will be disabled.",
            ru: "Локальное HTML5 хранилище недоступно. Операции сохранения не будут успешными."
        },
        49: {
            en: "<div class=\"normalWrap\">" +
                "<div class=\"center\">" +
                "<h3>Caché Web Terminal<span class=\"warning\"> v" + c[3] + "</span></h3>" +
                "</div>" +
                "<div class=\"center\">" +
                "<span class=\"syntax-_comment\">Global client command syntax</span><br>" +
                "a r <span class=\"syntax-_string\">\"g u\"</span> m e n t №0 <span class=\"syntax-_client\">/{command}</span>" +
                " argument1 <span class=\"syntax-_string\">\"argument2\"</span> ...<br>" +
                "</div>" +
                "<div>" +
                "Some examples:<br>" +
                "<span class=\"syntax-_client\">/define</span> &1 <span class=\"syntax-_string\">\"##class(%File)\"" +
                "</span> <span class=\"syntax-_comment\"> To use something like &1.Exists(\"Name\")</span><br>" +
                "<span class=\"syntax-_client\">/tail</span> <span class=\"syntax-_global\">^MyGlobal</span> " +
                "<span class=\"syntax-_comment\">To watch for global changes.</span><br>" +
                "<span class=\"syntax-_command\">do</span> <span class=\"syntax-_sysMacro\">##class</span><span class=\"" +
                "syntax-_bracket\">(</span><span class=\"syntax-mysuperapplication\">MySuperApplication</span><span cla" +
                "ss=\"syntax-_other\">.MySuperClass</span><span class=\"syntax-_bracket\">)</span><span class=\"syntax-" +
                "_other\">.MySuperMethod</span><span class=\"syntax-_bracket\">(</span><span class=\"syntax-mysuperargu" +
                "ments\">MySuperArguments</span><span class=\"syntax-_bracket\">)</span> <span class=\"syntax-_client\"" +
                ">/favorite</span> <span class=\"syntax-_other\">1</span> " +
                "<span class=\"syntax-_comment\">To save code before command into favorite slot 1.</span><br>&nbsp;" +
                "</div>" +
                "<table>" +
                "<tr>" +
                "<td class=\"hint\">Available client-side commands</td>" +
                "<td class=\"hint\">Description</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/help</td>" +
                "<td>Show help</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/tip [all]</td>" +
                "<td>Show tips and detail usage information. If \"all\" isn't present, it will be a tutorial for " +
                "you.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/echo [*]</td>" +
                "<td>Get back given arguments from server</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/save</td>" +
                "<td>Save current command history, settings and dictionary to local storage</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/load</td>" +
                "<td>Load current command history, settings and dictionary from local storage</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/reset</td>" +
                "<td>Reset whole terminal application to default settings, including server autocomplete files," +
                " client data, settings, etc.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/connect</td>" +
                "<td>Establish new connection to Caché server via <b>WebSocket</b> [deprecated]</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/disconnect</td>" +
                "<td>Disconnecting from current server [deprecated]</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/reconnect</td>" +
                "<td>Reopen server connection [deprecated]</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/clear</td>" +
                "<td>Clear terminal command log</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/define {redefinition} {definition}</td>" +
                "<td>Every occurrence of {definition} in input will be replaced with {redefinition}</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">{code} /favorite {slot}</td>" +
                "<td>Add code to favorites. You can load code anytime by calling /favorite {slot}</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">{/tail|/watch} {fileFullPath|globalName}</td>" +
                "<td>Watch for file/global changes. Execute command again to stop watching. This command without " +
                "arguments will stop watching for everything defined before</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/sql</td>" +
                "<td>Open/close integrated SQL shell</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/autocomplete [new]</td>" +
                "<td>" +
                "Load all class definitions for current namespace. This may take a while depending on your " +
                "system settings. Normally it takes 20-30 seconds for first execution. Next executions will " +
                "load already generated files or generate only namespace-specific language while new parameter given." +
                "To regenerate system language file (one which generates only first time) you have " +
                "to /reset whole terminal application." +
                "</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/siege {iterations = 120} {serverDelay = 0.02}</td>" +
                "<td>" +
                "Test client/server connection. Executes loops with delay on server and measures time/packages transferred." +
                "Be careful with serverDelay variable!" +
                "</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/settings</td>" +
                "<td>Open panel with different application settings. Use &lt;ESC&gt; to hide panel.</td>" +
                "</tr>" +
                "</table>" +
                "<div class=\"center\">" +
                "<h3>Controls</h3>" +
                "</div>" +
                "<table>" +
                "<tr>" +
                "<td class=\"hint\">Key</td>" +
                "<td class=\"hint\">Description</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">TAB</td>" +
                "<td>Extend current input with suggested autocomplete option</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">CTRL</td>" +
                "<td>If several autocomplete variants are present, change variant to next available</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">ALT</td>" +
                "<td>If several autocomplete variants are present, change variant to to previous available</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">UP/DOWN</td>" +
                "<td>Access to command history. <i>Current command won't be saved.</i></td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">SHIFT/CTRL + ENTER</td>" +
                "<td>Next line in current command stack.</td>" +
                "</tr>"+
                "<tr>" +
                "<td class=\"info\">ESC</td>" +
                "<td>Hide settings panel.</i></td>" +
                "</tr>" +
                "</table>" +
                "</div>",
            ru: "<div class=\"normalWrap\">" +
                "<div class=\"center\">" +
                "<h3>Caché Web Terminal<span class=\"warning\"> v" + c[3] + "</span></h3>" +
                "</div>" +
                "<div class=\"center\">" +
                "<span class=\"syntax-_comment\">Синтаксис команд с клиентской стороны</span><br>" +
                "а р <span class=\"syntax-_string\">\"г у\"</span> м е н т №0 <span class=\"syntax-_client\">/{command}</span>" +
                " аргумент1 <span class=\"syntax-_string\">\"аргумент2\"</span> ...<br>" +
                "</div>" +
                "<div>" +
                "Несколько примеров:<br>" +
                "<span class=\"syntax-_client\">/define</span> &1 <span class=\"syntax-_string\">\"##class(%File)\"" +
                "</span> <span class=\"syntax-_comment\"> Чтобы добиться следующего: &1.Exists(\"Name\")</span><br>" +
                "<span class=\"syntax-_client\">/tail</span> <span class=\"syntax-_global\">^MyGlobal</span> " +
                "<span class=\"syntax-_comment\">Чтобы следить за измерениями глобала.</span><br>" +
                "<span class=\"syntax-_command\">do</span> <span class=\"syntax-_sysMacro\">##class</span><span class=\"" +
                "syntax-_bracket\">(</span><span class=\"syntax-mysuperapplication\">MySuperApplication</span><span cla" +
                "ss=\"syntax-_other\">.MySuperClass</span><span class=\"syntax-_bracket\">)</span><span class=\"syntax-" +
                "_other\">.MySuperMethod</span><span class=\"syntax-_bracket\">(</span><span class=\"syntax-mysuperargu" +
                "ments\">MySuperArguments</span><span class=\"syntax-_bracket\">)</span> <span class=\"syntax-_client\"" +
                ">/favorite</span> <span class=\"syntax-_other\">1</span> " +
                "<span class=\"syntax-_comment\">Чтобы запомнить любимую команду в слот 1.</span><br>&nbsp;" +
                "</div>" +
                "<table>" +
                "<tr>" +
                "<td class=\"hint\">Доступные команды:</td>" +
                "<td class=\"hint\">Описание</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/help</td>" +
                "<td>Показать справку</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/tip [all]</td>" +
                "<td>Отобразить следующую часть детальной обучающей информации. Если \"all\" задано как аргумент, " +
                "выведет весь материал сразу.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/echo [*]</td>" +
                "<td>Вернуть поданные аргументы обратно.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/save</td>" +
                "<td>Сохранить текущие настройки, словарь, определения и историю в локальное хранилище браузера.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/load</td>" +
                "<td>Загрузить сохранённые настройки, словарь, определения и историю из локального хранилища.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/reset</td>" +
                "<td>Вернуть терминал в исходное состояние, тем самым удалив всю историю, настройки и сгенерированные " +
                "файлы на серверной стороне.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/connect</td>" +
                "<td>Установить новое соединение через <b>WebSocket</b> [устаревшее]</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/disconnect</td>" +
                "<td>Разорвать соединение с сервером [устаревшее]</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/reconnect</td>" +
                "<td>Обновить соединение с сервером [устаревшее]</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/clear</td>" +
                "<td>Очистить весь вывод.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/define {переопределение} {определение}</td>" +
                "<td>Определить {переопределение} как {определение}, что приведёт к замене всех последних первыми.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">{код} /favorite {слот}</td>" +
                "<td>Запомнить {код} в {слот}. Используйте /favorite {слот} чтобы загрузить {код}</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">{/tail|/watch} {ПолныйПутьКФайлу|ИмяГлобала}</td>" +
                "<td>Наблюдать за изменениями в файле/глобале. Выполните команду вновь, чтобы прекратить наблюдение. " +
                "Команда без аргументов остановит все наблюдения.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/sql</td>" +
                "<td>Перейти в или выйти из SQL-режима</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/autocomplete [new]</td>" +
                "<td>" +
                "Загружает определения классов и глобалов в словарь. Эта операция может занять некоторое время, в " +
                "зависимости от настроек системы. Обычно потребуется 20-30 секунд для первого выполнения команды. Все " +
                "последующие выполнения будут загружать уже сгенерированные файлы словаря с сервера. Системный словарь " +
                "генерируется дольше всех и только первый раз. Чтобы перегенерировать файлы словаря текущей области, " +
                "используйте аргумент \"new\". Команда /reset удалит все ранее сгенерированные файлы." +
                "</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/siege {итераций = 120} {задержка сервера = 0.02}</td>" +
                "<td>" +
                "Тестировать соединение. Выполняет тестовый код на сервере и измеряет количество пакетов и время их передачи. " +
                "Будьте внимательны при выборе аргументов." +
                "</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">/settings</td>" +
                "<td>Открыть панель настроек.</td>" +
                "</tr>" +
                "</table>" +
                "<div class=\"center\">" +
                "<h3>Управление</h3>" +
                "</div>" +
                "<table>" +
                "<tr>" +
                "<td class=\"hint\">Клавиша</td>" +
                "<td class=\"hint\">Описание</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">TAB</td>" +
                "<td>Дополнить ввод текущим вариантом автодополнения.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">CTRL</td>" +
                "<td>Следующий вариант автодополнения.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">ALT</td>" +
                "<td>Предыдущий вариант автодополнения.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">ВВЕРХ/ВНИЗ</td>" +
                "<td>Доступ к истории команд. <i>Текущая команда не будет сохранена</i>.</td>" +
                "</tr>" +
                "<tr>" +
                "<td class=\"info\">SHIFT/CTRL + ENTER</td>" +
                "<td>Переход на следующую строчку.</td>" +
                "</tr>"+
                "<tr>" +
                "<td class=\"info\">ESC</td>" +
                "<td>Спрятать панель настроек.</i></td>" +
                "</tr>" +
                "</table>" +
                "</div>"
        },
        50: {
            en: "<h1 class=\"center\">WebTerminal usage tips</h1>" +
                "<h3>This guide will show you detail description about application functionality.</h3>" +
                "<p>Note that you can call <span class=\"syntax-_client\">/help</span> command for list of available " +
                "commands any time you want. Client-side commands (that beginning with slash) are server-independent, " +
                "so you can relax by reading, for example, help information while heavy server command in progress.</p>" +
                "<p>Start by typing something like \"" + c[5] + "\". While entering " +
                "first letter, you can notice that there's " +
                "an autocompletion variant (darker highlighted) for command \"set\". You can press [TAB] key to perform " +
                "autocompletion. Also you can list available variants by pressing [CTRL] or [ALT], depending on direction" +
                "you need. After normal command execution try to execute \"" + c[6] +
                "\". You will notice available autocompletion variants for command \"write\" and for your variable \"test\". " +
                "Autocompletion both working for local variables and globals you've just defined." +
                "</p>",
            ru: "<h1 class=\"center\">Советы по использованию веб-терминала</h1>" +
                "<h3>Этот обучающий материал расскажет вам об основных возможностях приложения.</h3>" +
                "<p>На заметку: вы всегда можете выполнить команду <span class=\"syntax-_client\">/help</span> и получить " +
                "справочную информацию. Клиентские команды (которые начинаются со слеша) не зависят от сервера, " +
                "потому, к примеру, можно читать справку или эту информацию во время выполнения тяжёлой команды на сервере.</p>" +
                "<p>Начните с ввода чего-то похожего на \"" + c[5] + "\". Пока вы вводите команду set, можно заметить " +
                "возникающую подсказку - это вариант автодополнения. По нажатию [TAB] тусклый текст превращается в обычный. " +
                "Если доступно несколько вариантов, и получится перелистывать их нажатиями [CTRL] или [ALT], в зависимости от " +
                "требуемого направления. После нормального выполнения команды попробуйте выполнить \"" + c[6] +
                "\". Будет заметно, что варианты автодополнения будут доступны не только для \"write\", но и для \"test\". " +
                "Точно так же будет и с глобалами, которые вы только что определили." +
                "</p>"
        },
        51: {
            en: "<p>As you may have noticed, there's a set of client-side commands you can " +
                "execute. This is client-side command. Every client-side command can have a list of arguments. Here's the " +
                "rules of passing arguments in examples: </p><ul><li>" + parser.highlightHTML("/command argument1 argument2 ...") + "</li>" +
                "<li>" + parser.highlightHTML("/command \"argument1 with spaces\" argument_2 \"\" it_was_argument_3 ...") +
                "</li><li>" + parser.highlightHTML("argument №1 /command") + "</li>" +
                "<li>" + parser.highlightHTML("a r g u \"m\" e n t 1 /command \"a r g u m e n t 2\" argument3 ...") + "</li></ul>" +
                "<p>You can play with arguments by using " + parser.highlightHTML("/echo") + " command. Try to pass something " +
                "scary withing this command and see the result.</p>",
            ru: "<p>Как вы могли заметить, существует набор команд, которые можно выполнять " +
                "на клиентской части. Каждая такая команда может иметь набор аргументов. Вот некоторые правила их передачи: " +
                "</p><ul><li>" + parser.highlightHTML("/команда аргумент1 аргумент2 ...") + "</li>" +
                "<li>" + parser.highlightHTML("/команда \"аргумент1 с пробелами\" аргумент_2 \"\" Это_был_третий_аргумент ...") +
                "</li><li>" + parser.highlightHTML("аргумент №1 /команда") + "</li>" +
                "<li>" + parser.highlightHTML("а р г у \"м\" е н т 1 /команда \"а р г у м е н т 2\" аргумент3 ...") + "</li></ul>" +
                "<p>Можно более детально изучить работу парсера аргументов, исполнив команду  " + parser.highlightHTML("/echo") + ". " +
                "Сервер отдаст вам каждый аргумент с новой строчки.</p>"
        },
        52: {
            en: "<p>Let's explore a little more about autocompletion. For example, you wishes to autocomplete " +
                "your current classes in namespace. Because of large base of variants available, this implemented by " +
                parser.highlightHTML("/autocomplete") + "</span> command. By calling this command you will cause " +
                "client to request server for namespace autocomplete data. In case of first execution file will be " +
                "automatically generated. This may take a while depending on number of classes present. Normally it takes " +
                "15-20 seconds to perform this operation. After autocomplete file generate, it will be loaded immediately " +
                "and you will get <span class=\"syntax-_string\">\"Language for [namespace] merged.\"</span> message. " +
                "Calling this command again and again will cause loading already generated autocomplete file. If you " +
                "wish to regenerate this file, then execute this command with \"new\" argument: \"" +
                parser.highlightHTML("/autocomplete new") + "\". </p>",
            ru: "<p>Теперь стоит добавить еще кое-что про автодополнение. Допустим, вам потребовалось дополнять классы " +
                "и методы в текущем пространстве имён. Из-за большой базы всех этих слов, такое достигается за счёт выполнения команды " +
                parser.highlightHTML("/autocomplete") + "</span>. Вызывая эту команду, вы заставите сервер сгенерировать " +
                "файлы с данными, которые будут подгружены, или подгрузить уже существующие. Первое выполнение команды может " +
                "стать затратным, так как будет сгенерирован большой файл системных классов. Он генерируется единожды и удаляется только в случае команды "+c[7]+". Данная операция может занять 15-20 секунд, это " +
                "нормально. После подгрузки сгенерированного \"словаря\" вы получите уведомление об успешности операции слития с уже существующим словарём. " +
                "Последующие вызовы команды будут просто подгружать уже сгенерированные файлы. Если словарь для текущего пространства имён требуется сгенерировать заново, выполните \"" +
                parser.highlightHTML("/autocomplete new") + "\". </p>"
        },
        53: {
            en: "<p>Terminal application has different settings you can change. Simply call " +
                c[8] + " command and you will get a panel with list of options. To close " +
                "panel press [ESC] or click \"Close\" at upper right corner.</p><p>One important thing to know about " +
                "settings - they're automatically saving and storing in your local browser (localStorage). So you can " +
                "continue your work with terminal with same settings after web page closed and opened again. But make " +
                "sure that this works only for one domain. None of settings are storing on server.</p>",
            ru: "<p>Приложение терминала имеет множество настроек. Просто выполните " +
                c[8] + " и вы увидите панель с настройками. Чтобы закрыть панель, нажмите " +
                "[ESC] или кликните \"Закрыть\" в правом верхнем углу.</p><p>Еще одно, что важно знать о настройках - " +
                "они автоматически сохраняются в локальное хранилище браузера. Продолжать работу можно будет с теми же " +
                "настройками, что были ранее. Но стоит заметить, что это работает только для одного домена. Настройки " +
                "не хранятся на сервере.</p>"
        },
        54: {
            en: "<p>Another thing storing in localStorage is terminal language and command history. Terminal " +
                "language - it's a special object which includes all keywords and autocomplete data with the rules of " +
                "autocompletion. After " + parser.highlightHTML("/save") + " command call, your settings, language and " +
                "history will be saved. Anytime you want it is possible to restore this settings - just call " +
                parser.highlightHTML("/load") + " command. " + parser.highlightHTML("/reset") + " command will " +
                "bring terminal to initial state.</p>",
            ru: "<p>Так же успешно, как и настройки, в локальное хранилище попадает словарь, история и определения. Словарь " +
                "- это специальный объект, который включает в себя базу слов, необходимую для работы автодополнения и анализа. " +
                "После вызова команды " + parser.highlightHTML("/save") + " всё вышеперечисленное будет копировано в хранилище. " +
                "В любой другой момент можно загрузить это, выполнив команду " +
                parser.highlightHTML("/load") + ". " + parser.highlightHTML("/reset") + " сотрёт всё, вернув терминал в исходное состояние.</p>"
        },
        55: {
            en: "<p>There are more features you can obtain with client-side commands.</p><p>First, you can use " +
                parser.highlightHTML("/sql") + " command to enter and exit simple sql-mode. Easiest then ever.</p><p>" +
                "Next, it is easy to define " +
                "any big command by using " + parser.highlightHTML("/define") + " command. Try to execute something like </p><p>" +
                parser.highlightHTML("##class(%Library.File).Exists( /define ?f(") + "</p><p> and sure how it works by " +
                "executing </p><p>" + parser.highlightHTML("write ?f(\"C:\")") + "</p><p>Do not forget about autocomplete! " +
                "If you didn't, use " + parser.highlightHTML("/autocomplete") + " option to load classes and examine how it " +
                "helps. Autocompletion have to help you enter \"%Library.File\" class and it's method \"Exists\".</p>" +
                "<p>Another cool thing is watching " +
                "(or tailing). You can call " + parser.highlightHTML("/watch or /tail") + " command with one argument - " +
                "file path or global name. Let's imagine that you have file " + parser.highlightHTML("C:\\temp\\log.txt") + " or global " +
                parser.highlightHTML("^myLog") + ". Then you can call " + parser.highlightHTML("/tail ^myLog") + " or " +
                parser.highlightHTML("/watch C:\\temp\\log.txt") + " and look for their's changes.</p>",
            ru: "<p>Теперь стоит рассмотреть, на что способны клиентские команды.</p><p>Для начала, следует попробовать " +
                parser.highlightHTML("/sql") + " режим. Он позволит быстро выполнять SQL-запросы.</p><p>" +
                "Затем, можно определить любое сокращение, используя " +
                parser.highlightHTML("/define") + ". Попробуйте выполнить </p><p>" +
                parser.highlightHTML("##class(%Library.File).Exists( /define ?f(") + "</p><p> и убедитесь в том, как это работает,  " +
                "выполнив </p><p>" + parser.highlightHTML("write ?f(\"C:\")") + "</p><p>Не забывайте про автодополнение! " +
                "Выполните " + parser.highlightHTML("/autocomplete") + ", чтобы загрузить базу классов и их свойств. " +
                "Это должно помочь вам быстрее набрать тот самый Library.File и его метод Exists.</p>" +
                "<p>Другая интересная вещь - это наблюдение за переменными. " +
                "Вызовом " + parser.highlightHTML("/watch или /tail") + " с аргументом глобала или файла можно начать наблюдать за изменениями в них. " +
                "Давайте представим, что у вас есть файл " + parser.highlightHTML("C:\\temp\\log.txt") + " или глобал " +
                parser.highlightHTML("^myLog") + ". Выполните " + parser.highlightHTML("/tail ^myLog") + " или " +
                parser.highlightHTML("/watch C:\\temp\\log.txt") + " и попробуйте их изменить. Стоит заметить, что для глобала это " +
                "действительно только в случае добавления измерений.</p>"
        },
        56: {
            en: "<p>And finally try to use " + parser.highlightHTML("/favorite") + " command: write a piece of " +
                "code or whole program, test it and then join " + parser.highlightHTML("/favorite 1") + " to the end " +
                "of command line. This will remember you command to slot 1. Then simply call " + parser.highlightHTML("/favorite 1") +
                " (with one argument) and use use saved code again.</p><p>And that's the end of out tutorial! Do not forget " +
                "to " + parser.highlightHTML("/save") + " your history and favorites, or just use \"autosave\" option " +
                "available in settings.</p>",
            ru: "<p>Ну и в завершение попробуйте " + parser.highlightHTML("/favorite") + ": напишите часть кода или целую программу, " +
                "после чего добавьте в конец " + parser.highlightHTML("/favorite 1") +
                ". Это запомнит команду (программу) в первый слот. Потом простым вызовом " + parser.highlightHTML("/favorite 1") +
                " (с одним аргументом) можно будет снова применить код.</p><p>И на этом всё! Не забывайте сохранять (" +
                parser.highlightHTML("/save") + ") вашу историю или просто поставьте галочку напротив \"автосохранения\" в " +
                "настройках.</p>"
        },
        57: {
            en: "<p>Enjoy!</p>",
            ru: "<p>Приятного администрирования!</p>"
        },
        58: {
            en: "<p>To continue, type <span class=\"syntax-_client\">/tip</span> command again.</p>",
            ru: "<p>Чтобы продолжить, введите команду <span class=\"syntax-_client\">/tip</span> снова.</p>"
        },
        59: {
            en: "<p>Type <span class=\"syntax-_client\">/tip</span> command again, or just use " +
                "arrow [UP] key if you typed <span class=\"syntax-_client\">/tip</span> command before.</p>",
            ru: "<p>Введите <span class=\"syntax-_client\">/tip</span> вновь, или просто " +
                "нажмите стрелку вверх если вы уже вводили эту команду ранее."
        },
        60: {
            en: "<p>Continue typing <span class=\"syntax-_client\">/tip</span> if you want more " +
                "information.</p>",
            ru: "<p>Продолжайте вводить <span class=\"syntax-_client\">/tip</span> в том же духе, чтобы получить больше информации."
        },
        61: {
            en: "Reload the page to apply changes.",
            ru: "Обновите страницу, чтобы применить изменения."
        },
        62: {
            en: "Close",
            ru: "Закрыть"
        },
        63: {
            en: "Control panel",
            ru: "Панель настроек"
        },
        64: {
            en: "Application settings",
            ru: "Настройки приложения"
        },
        65: {
            en: "Highlighting",
            ru: "Подсветка синтаксиса"
        },
        66: {
            en: "Use syntax highlighting",
            ru: "Использовать подсветку синтаксиса"
        },
        67: {
            en: "Parse output",
            ru: "Парсить вывод"
        },
        68: {
            en: "Highlighting terminal output data",
            ru: "Подсвечивать вывод терминала"
        },
        69: {
            en: "Clean startup",
            ru: "Чистый старт"
        },
        70: {
            en: "Do not show additional information during terminal startup",
            ru: "Не показывать дополнительную информацию при загрузке терминала"
        },
        71: {
            en: "Animations",
            ru: "Анимации"
        },
        72: {
            en: "Animate output and some of terminal elements",
            ru: "Анимировать вывод и некоторые элементы терминала"
        },
        73: {
            en: "AutoSaving",
            ru: "Автосохранение"
        },
        74: {
            en: "Execute save command automatically after application close",
            ru: "Выполнять команду сохранения автоматически по закрытию приложения"
        },
        75: {
            en: "Language",
            ru: "Язык"
        },
        76: {
            en: "Color theme",
            ru: "Тема оформления"
        },
        77: {
            en: "Caché WEB Terminal",
            ru: "WEB-терминал Caché"
        },
        78: {
            en: "Logged as",
            ru: "Вход выполнен для"
        },
        79: {
            en: "Login failed.",
            ru: "Вход не выполнен."
        }
    };

    this.setLanguage = function(lang) {
        if (languages.hasOwnProperty(lang)) {
            currentLanguage = lang
        } else log.write("No available translations for \"" + lang + "\". Use " + function(){
            var s = "";
            for (var p in languages) { if (languages.hasOwnProperty(p)) s += "|\"" + p + "\"" }
            return s.substr(1);
        }() + ".")
    };

    /**
     * Returns language constant according to current language.
     */
    this.get = function(languageConstID) {
        var err = "[[No translation, id=" + languageConstID + "]]";
        return (languageBase[languageConstID])?languageBase[languageConstID][currentLanguage] || err:err;
    };

    this.setLanguage((storage.get("settings") || {}).language || "en");

    this.initialize = function() {
        c[3] = ((typeof application !== "undefined")?application.version():"unknown")
    }

};]]></CSP>


<CSP name="WebTerminal/js/parser.js" application="/csp/sys/" default="1"><![CDATA[
/**
 * Every parser tasks are performed only with strings.
 */
var parser = new function() {

    /**
     * Converts text with html-tags and entities to normal plaintext string.
     *
     * @param string
     * @returns {string}
     *
    this.HTMLtoText = function(string) {
        var div = document.createElement("div"); // @GC
        div.innerHTML = string;
        var text = div.textContent || div.innerText || string.replace(/<br\s?\/?>/g,"\n").replace(/<\/?[^>]+(>|$)/g,"");
        return text || "";
    };
     */

    /**
     * Function clears html tab characters and entities.
     *
     * @param string
     * @returns {string}
     */
    this.clearHTML = function(string) {
        return string.replace("&","&amp;").replace("<","&lt;").replace("<","&gt;")
    };

    /**
     * Reverses the string.
     *
     * @param string
     * @returns {string}
     */
    this.reverse = function(string) {
        return string.split("").reverse().join("");
    };

    /**
     * Analyzing stringPart, function returns correct name of element to use.
     * Usage: for example, to form highlighting "class" attribute. "set" -> "-set"
     * "$function" -> "-f_function", "$$$macro" -> "-m_macro" etc.
     *
     * @param stringPart
     *  Part of string, which name needed to return.
     */
    var parserSyntaxGetAttrName = function(stringPart) {

        var result = null;
        stringPart = stringPart.toLowerCase();
        if (typeof terminal !== "undefined" && terminal.language.tokens.commands.hasOwnProperty(stringPart)) {
            result = "_command"
        } else if (stringPart.match(/^[a-zA-Z][a-zA-Z0-9]*$/)) { // simple words
            result = stringPart.toLowerCase();
        } else if (stringPart.match(/^[0-9]+\.?[0-9]+$/)) {
            result = "_digit"
        } else if (stringPart.match(/^".*"$/)) {
            result = "_string"
        } else if (stringPart.match(/^\/[a-z]+$/)) {
            result = "_client"
        } else if (stringPart.match(/^\$[a-zA-Z][a-zA-Z0-9]*$/)) {
            result = "_function"
        } else if (stringPart.match(/^\$\$[a-zA-Z][a-zA-Z0-9]*$/)) {
            result = "_userFunction"
        } else if (stringPart.match(/^[{}\]\[\(\)]+$/)) {
            result = "_bracket"
        } else if (stringPart.match(/^\^%?[a-zA-Z][a-zA-Z0-9]*$/)) {
            result = "_global"
        } else if (stringPart.match(/^##[a-zA-Z][a-zA-Z0-9]*$/)) {
            result = "_sysMacro"
        } else if (stringPart.match(/^\.\.[a-zA-Z][a-zA-Z0-9]*$/)) {
            result = "_classProp"
        } else if (stringPart.match(/^\$\$\$[a-zA-Z][a-zA-Z0-9]*$/)) {
            result = "_macro"
        } else if (stringPart.match(/^[\+\-=\*\/<>\\!_'#\?]+$/)) {
            result = "_symbol"
        } else if (stringPart.match(/^(\/\*.*?(?=\*\/)\*\/)$/)) {
            result = "_comment"
        } else { result = "_other" }
        return (result)?"-"+result:result;

    };

    /**
     * Function breaks code for parts with span tags and according styles, but skips &*; html-symbol combinations and tag <br>
     *
     * @param string
     *  String to parse.
     * @returns {string}
     *  Parsed string.
     */
    this.highlightHTML = function(string) {
        if (typeof settings !== "undefined" && !settings.highlightOutput()) return string;
        return string.replace(/(\/\*.*?(?=\*\/)\*\/)|([0-9]+\.?[0-9]+?)|(((<|&|&#)|(\^%?)|\/|\${0,3}|#{0,2}|%|\.|(\.\.))?[A-Za-z0-9]+[;>]?)|[{}\]\[\(\)!_'\\#\?\+\-\*\/=<>,]|("[^"]*")/g,
            function(part) {
                return "<span class=\"syntax" + parserSyntaxGetAttrName(part) + "\">" + part + "</span>";
            });
    };

    /**
     * Converts position in plaintext string to it's html position. Works only with correct-html strings: tags has
     * theirs closures and HTML-entities represented as &<anySymbols>;
     *
     * @param string
     * @param position
     */
    this.convertPositionForHTML = function(string,position) {

        var i = 0, l = string.length, pos = 0;
        while (i<l && pos<position) {
            if (string[i]=="&") {
                var m = string.substr(i+1,5).match(/(nbsp|lt|gt|amp|#09);/g);
                if (m) i += m[0].length;
            } else if (string[i]=="<") {
                var p = string.indexOf(">",i+1);
                var inside = string.substring(i+1,p);
                if (inside == "br" || inside.substr(0,3) == "br/" || inside.substr(0,3) == "br ") {
                    pos++;
                }
                if (p==-1) { i = pos = l-1 } else { i += p-i; pos--; }
            }
            pos++; i++;
        }
        return i;

    };

    /**
     * Dummy converting JSON string to object.
     *
     * @param json {string}
     */
    this.jsonToObject = function(json) {
        if (JSON && JSON.parse) return JSON.parse(json);
        var a = null;
        eval("a = " + json);
        return a;
    };

    /**
     * Dummy converting object to JSON string.
     *
     * @param object
     */
    this.objectToJson = function(object) {
        if (typeof object !== "object" || typeof JSON === "undefined") return "";
        return JSON.stringify(object);
    };

    /**
     * Inserts caret <span> object to given HTML string.
     *
     * @param string
     * @param position
     * @returns {string}
     */
    this.insertCaret = function(string,position) {
        position = this.convertPositionForHTML(string,position);
        return string.splice(position,0,"<span id=\"caret\"></span>");
    };

    /**
     * Returns parsed string by given rules.
     *
     * @param string
     * [ @param insertCaretPos ]
     * [ @param highlight ]
     * [ @param insertSuggestion ]
     * @returns {string}
     */
    this.prepareForOutputHTML = function(string,insertCaretPos,highlight,insertSuggestion) {

        if (typeof insertCaretPos == "undefined") insertCaretPos = -1;
        if (typeof highlight == "undefined") highlight = true;
        if (typeof insertSuggestion == "undefined") insertSuggestion = "";
        if (insertSuggestion == 1) { insertSuggestion = terminal.autocompletion.getSuggestion() }
        if (insertSuggestion) insertSuggestion = "<span class=\"terminal-suggestion\">" + insertSuggestion + "</span>";

        string = string.replace(/[&<>]/g,function(part,index){
            var r = "";
            switch (part) {
                case "&": r = "&amp;"; break;
                case "<": r = "&lt;"; break;
                case ">": r = "&gt;"; break;
            }
            if (!insertCaretPos || r === "") {
                return r || part;
            }
            if (index < insertCaretPos) {
                //insertCaretPos += r.length - part.length; // seek caret
            }
            return r;
        });

        if (highlight) string = this.highlightHTML(string);
        if (insertCaretPos > -1) {
            if (insertSuggestion) {
                var pos = this.convertPositionForHTML(string,insertCaretPos);
                string = string.splice(pos,0,insertSuggestion);
            }
            if (application.browser != "ie") {
                string = this.insertCaret(string,insertCaretPos);
            }
        }

        return string;

    };

    /**
     * Receive all available autocomplete variants as an array.
     */
    this.getAutocomplete = function(string,position) {

        // limitations: \s, \n, next-letter
        var nextChar = string.charAt(position),
            currentChar = string.charAt(position-1);
        if (nextChar.match(/[a-zA-Z]/) || currentChar.match(/\s/)) return {};

        // part to parse: reversed+" "
        var part = string.substring(0,position).trim(),
            variants = {
                length: 0,
                data: {
                    /*
                    "nding": { // name - part variant
                        origin: {
                            // origin autocomplete object reference
                        },
                        full: "ending", // full variant
                        part: "nding", // part variant
                        p: 1 // order priority
                    }
                     */
                }
            };

        var getEndings = function(object, startPart, separator, caseSensitive) {
            var lowerCase;
            lowerCase = true;
            if (!caseSensitive) {
                if (!startPart) return;
                if (startPart[startPart.length-1].match(/[A-Z]/)) lowerCase = false;
                startPart = startPart.toLowerCase();
            }
            for (var fullPart in object) {
                if (!object.hasOwnProperty(fullPart) || typeof object != "object") continue;

                if (fullPart.indexOf(startPart) === 0 && fullPart.length != startPart.length) {
                    if (fullPart.charAt(0) === "!") continue;
                    var part = fullPart.substr(startPart.length);
                    if (separator) part = part.split(separator)[0];
                    if (!variants["data"].hasOwnProperty(part)) {
                        var freq = object[fullPart];
                        if (typeof freq !== "number") {
                            if (!freq.hasOwnProperty("!p")) freq["!p"] = 0;
                            freq = freq["!p"];
                        }
                        variants["data"][part] = {
                            origin: object,
                            full: fullPart,
                            part: (lowerCase)?part:part.toUpperCase(),
                            p: freq
                        };
                        variants["length"]++;
                    }
                }
            }
        };
        
        var parseObject = function(languageObject, string) {

            for (var unit in languageObject) {

                if (!languageObject.hasOwnProperty(unit) ||
                    !(languageObject[unit].hasOwnProperty("!autocomplete"))) continue;

                var parameters = languageObject[unit]["!autocomplete"];
                if (!parameters) continue;
                if (typeof parameters["caseSensitive"] === "undefined") parameters["caseSensitive"] = true;

                if (parameters["child"] && parameters["child"]["reversedRegExp"]) { // scanning for child elements
                    var combinedRegExp = new RegExp(parameters["child"]["reversedRegExp"] +
                        parameters["reversedRegExp"]);
                    var childResult = combinedRegExp.exec(string);
                    if (childResult && childResult.index === 0 && childResult[2]) {
                        var parentName = parser.reverse(childResult[2]);
                        if (languageObject[unit].hasOwnProperty(parentName)) {
                            getEndings(languageObject[unit][parentName], parser.reverse(childResult[1]),
                                parameters["child"]["separator"], parameters["caseSensitive"])
                        }
                    }
                }

                var regExp = new RegExp(parameters["reversedRegExp"]),
                    result = regExp.exec(string);
                if (result && result.index === 0 && result[1]) {
                    getEndings(languageObject[unit], parser.reverse(result[1]), parameters["separator"],
                        parameters["caseSensitive"])
                }

            }

        };

        parseObject(terminal.language.tokens,this.reverse(part)+" ");

        return variants;

    };

};]]></CSP>


<CSP name="WebTerminal/js/server.js" application="/csp/sys/" default="1"><![CDATA[
var server = new function() {

    var socket = null, // webSocket object
        serverRoot = "%WebTerminal.Engine.cls", // name of Cache class
        LOG_DATA = false;

    var logData = function(direction,string) {
        log.write(
            "DATA " + ((direction)?"to":"from") + " server: (" + ((string)?string.charCodeAt(0):"empty") + ") ",string
        );
    };

    /**
     * Shows if client currently connected to server.
     *
     * @returns {boolean|string}
     *  If connected, returns server ws URL.
     */
    this.connected = function() {
        return (socket == null)?false:socket.url;
    };

    /**
     * Disconnect from server.
     */
    this.disconnect = function() {
        terminal.watches.stopAll();
        if (server.connected()) {
            terminal.output.write(lang.get(36));
            socket.close();
            socket = null;
            terminal.namespace.set(lang.get(4));
        } else terminal.output.write(lang.get(37))
    };

    /**
     * Requests autocomplete for namespace.
     *
     * @param namespace
     */
    this.requestAutocompleteFile = function(namespace) {
        terminal.output.write(lang.get(38) + " " + namespace.replace(/_/g,"%"));
        ajax.get("js/autocomplete/" + namespace + ".js",function(data,allRight){
            namespace = namespace.replace(/_/g,"%");
            if (allRight) {
                var obj = parser.jsonToObject(data);
                if (!obj.hasOwnProperty("class")) {
                    terminal.output.write(lang.get(39) + " " + namespace + ".");
                } else {
                    if (obj.hasOwnProperty("class")) terminal.language.addClasses(obj.class);
                    if (obj.hasOwnProperty("global")) terminal.language.addGlobals(obj.global);
                    terminal.output.write(lang.get(40) + " " + namespace + " " + lang.get(41));
                }
            } else {
                terminal.output.write(lang.get(40) + namespace + " " + lang.get(42));
            }
        });
    };

    /**
     * Return default webSocket URL to connect on current domain.
     *
     * @returns {string}
     */
    this.getDefaultServerURL = function() {
        var part = document.URL.split("/")[2]; // domain[:port]

        if (application.debug) part = application.debugUrlPart;

        return "ws://" + part + "/" + serverRoot.replace(/%/,"%25");
    };

    /**
     * Connect to server. If url isn't passed, it will be generated from current expecting the same domain.
     * E.g. "http://localhost:81/..." will become "ws://localhost:81/<serverRoot>"
     *
     * [ @param url ]
     *  WebSocket server core URL starting with "ws://"
     * @returns {boolean}
     */
    this.connect = function(url) {

        if (this.connected()) {
            terminal.output.write(lang.get(43));
            return false;
        }
        if (typeof url == "undefined" || typeof url != "string" || !url) { url = this.getDefaultServerURL() }
        socket = new WebSocket(url);
        socket.onopen = onOpen;
        socket.onclose = onClose;
        socket.onmessage = onMessage;
        socket.onerror = onError;
        return true;

    };

    /**
     * Submits clear data to server. Default terminator: true.
     * Data will be trimmed and \n'd if terminator true
     *
     * @param action
     * [ @param data ]
     * [ @param terminator ]
     */
    this.submit = function(action,data,terminator) {
        if (typeof terminator == "undefined") terminator = true;
        if (!data) data = "";
        data = data.trim().replace(/\r\n|\r|\n/g,"\n") + ((terminator)?"\n":"");
        if (socket) {
            socket.send((action || "") + data);
        } else {
            terminal.output.write(lang.get(44))
        }
    };

    this.send = function(data) {
        if (LOG_DATA) logData(1,data);
        if (!this.connected()) { log.write("Unable to send data to server: no connection established.") }
        socket.send(data);
    };

    var onOpen = function() {
        if (application.authorizationKey) server.send(application.authorizationKey);
    };

    var onClose = function(a) {
        terminal.output.write(lang.get(45) + " " + a.code + " " + a.reason);
    };

    var onMessage = function(event) {
        if (LOG_DATA) logData(0,event.data);
        terminal.handlers.serverMessage(event.data);
    };

    var onError = function(error) {
        terminal.output.write(lang.get(46) + " ",error)
    };

};

var ajax = new function() {

    function getXmlHttp() {
        var xmlhttp;
        try {
            xmlhttp = new ActiveXObject("Msxml2.XMLHTTP");
        } catch (e) {
            try {
                xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
            } catch (E) {
                xmlhttp = false;
            }
        }
        if (!xmlhttp && typeof XMLHttpRequest!='undefined') {
            xmlhttp = new XMLHttpRequest();
        }
        return xmlhttp;
    }

    /**
     * Gets data from server and handles it with handler.
     *
     * @param url
     * @param handler
     * [ @param caching ]
     */
    this.get = function(url, handler, caching) {

        if (typeof caching === "undefined") caching = false;
        var req = getXmlHttp();
        caching = "cache=" + ((caching)?1:new Date().getTime());

        req.onreadystatechange = function() {

            if (req.readyState == 4) { //req.statusText

                if(req.status == 200) {
                    handler.call(null,req.responseText,1);
                } else {
                    handler.call(null,null,0);
                    log.write("Ajax GET error: ",req.statusText,req.responseText);
                }

            }

        };

        var s = (url.indexOf("?") === -1)?"?":"&";

        req.open("GET", url + s + caching, true);
        req.send(null);

    }

};]]></CSP>


<CSP name="WebTerminal/js/storage.js" application="/csp/sys/" default="1"><![CDATA[
/**
 * Local data storage object for saving/loading settings.
 *
 * Required:
 *  parser
 */
var storage = new function() {

    /** --- reserved ---
     * lastSaveDate
     * restoreSession # after set up, the next terminal initialization will restore data from local storage.
     */

    /**
     * Returns last saved date or null pointing to loading ability.
     * @returns {Date || undefined}
     */
    this.lastSave = function() {
        return this.get("lastSaveDate");
    };

    /**
     * Forces to modify last save data.
     */
    this.modifySave = function() {
        var date = new Date();
        localStorage.setItem("lastSaveDate", date.valueOf());
    };

    /**
     * Clears all stored data.
     */
    this.clear = function() {
        localStorage.clear();
    };

    /**
     * Checks if local storage is available.
     *
     * @returns {boolean}
     */
    this.available = function() {
        try {
            return "localStorage" in window && window["localStorage"] !== null;
        } catch (e) {
            return false;
        }
    };

    /**
     * Sets the local storage key.
     *
     * @param key
     * @param value
     */
    this.set = function(key, value) {
        if (!this.available()) return;
        var data = value;
        if (typeof value === "object") data = parser.objectToJson(value);
        try {
            localStorage[key] = data;
        } catch (e) {
            terminal.output.write(lang.get(47))
        }
    };

    /**
     * Removes key from storage.
     *
     * @param key
     */
    this.delete = function(key) {
        if (localStorage && localStorage.hasOwnProperty(key)) {
            delete localStorage[key];
        }
    };

    /**
     * Gets local storage key value.
     *
     * @param key
     * @returns {*}
     */
    this.get = function(key) {
        if (!this.available()) return undefined;
        var data = localStorage[key];
        try {
            data = parser.jsonToObject(data)
        } catch (e) {

        }
        return data;
    };

    /**
     * Storage initialization.
     */
    this.initialize = function() {
        if (!this.available()) {
            terminal.output.write(lang.get(48))
        }
    }

};]]></CSP>


<CSP name="WebTerminal/js/terminal.js" application="/csp/sys/" default="1"><![CDATA[
/**
 * Main controller object for application.
 *
 * @author ZitRo
 *
 * Required objects:
 *  server, parser, log, dom, hid, application
 *
 * Under unit test: unit.js
 *
 * Cache terminal protocol over-WebSocket description (CTWPv3):
 *
 *  AUTHORIZATION:
 *      First package from client includes ONLY authorization key in clear text form. If this key is invalid, server
 *      closes connection immediately. If server accepts key, main terminal session starts.
 *
 *  MESSAGING:
 *      Every client-server package (except clear I/O mode) includes one action-identifier byte. This byte tells what to
 *      perform on received side. The next table of action bytes are in use:
 *
 *      BYTE    SERVER received                             CLIENT received
 *      0       Ignore body                                 Ignore body
 *      1       Execute body                                Enter clear I/O mode (execution begins)
 *      2       Execute sql body                            Exit clear I/O mode (with "exit" body)
 *      3       Generate autocomplete (body - flag)         Output message
 *      4       Watch (body: name)                          Change namespace
 *      5       Check watches                               Load autocomplete
 *      6       RESET to default                            Read string
 *      7       ECHO (body)                                 Read char
 *      8                                                   Authorization status (body: 1/0)
 *      9                                                   Watch (body: name)
 *		10													LoginInfo (body: user logged in)
 *  
 *	Clear I/O mode
 *      In this mode terminal client will listen for data from server and output any data as it is, without any action
 *      identifiers. The same with terminal: any data sent to server won't include any identifiers.
 *
 */
var terminal = new function() {

    var receiveDataHandler = null; // Server data handler. If function returns false, terminal won't process data.

    /**
     * Current terminal mode. Mode determines it's behavior.
     *
     * @type {{number}}
     */
    this.modes = {
        NORMAL: 0, // executing commands on server
        CLEAR_IO: 3,// real-time execution (while messaging) mode until /END/ from server
        SQL: 1, // executing sql queries
        MACRO: 2, // macro recording (set of commands)
        DEFAULT: 0, // default terminal mode
        LAST: 0 // determines last switched mode (functional, do not change)
    };

    /**
     * Actions identifiers for client (browser).
     *
     * @type {{string}}
     */
    this.clientActions = {
        NONE: String.fromCharCode(0), // useless action
        ENTER_CLEAR_IO: String.fromCharCode(1),// enters clear IO. In this mode terminal won't send action id
        EXIT_CLEAR_IO: String.fromCharCode(2),// exits clear IO
        OUTPUT: String.fromCharCode(3), // just outputs message body
        CHANGE_NAMESPACE: String.fromCharCode(4), // changes namespace
        LOAD_AUTOCOMPLETE: String.fromCharCode(5), // loads autocomplete file. Body holds only namespace
        READ_STRING: String.fromCharCode(6), // reads string - removes namespace like in common terminal
        READ_CHARACTER: String.fromCharCode(7), // reads character - removes namespace like in common terminal
        AUTHORIZATION_STATUS: String.fromCharCode(8), // alerts client about authorization success. Holds 1/0
        WATCH: String.fromCharCode(9), // start watching
        LOGIN_INFO: String.fromCharCode(10)
    };

    /**
     * Action identifiers for server.
     *
     * @type {{string}}
     */
    this.serverActions = {
        NONE: String.fromCharCode(0),
        EXECUTE: String.fromCharCode(1),
        EXECUTE_SQL: String.fromCharCode(2),
        GENERATE_AUTOCOMPLETE: String.fromCharCode(3),
        WATCH: String.fromCharCode(4),
        CHECK_WATCH: String.fromCharCode(5),
        RESET: String.fromCharCode(6),
        ECHO: String.fromCharCode(7)
    };

    this.mode = this.modes.DEFAULT; // mode changes current terminal submit action, look and behavior
    this.ready = false;

    /**
     * Saves terminal state (history, autocomplete, etc.) to local storage.
     */
    this.saveState = function() {

        storage.set("history", terminal.history.export());
        storage.set("language", terminal.language.export());
        storage.set("favorites", terminal.favorites.export());
        storage.set("definitions", terminal.definitions.export());
        storage.set("settings", settings.export());
        storage.modifySave();
        terminal.output.write(lang.get(6))

    };

    /**
     * Loads saved terminal state from local storage, including history, autocomplete objects, ets.
     *
     * @returns {boolean}
     */
    this.loadState = function() {

        if (typeof storage.lastSave() === "undefined") {
            terminal.output.write(lang.get(7));
            return false;
        }

        settings.import(storage.get("settings"));
        terminal.history.import(storage.get("history"));
        terminal.language.import(storage.get("language"));
        var favs = storage.get("favorites");
        if (favs) terminal.favorites.import(favs);
        var defs = storage.get("definitions");
        if (defs) terminal.definitions.import(defs);
        if (!settings.get_cleanStartup()) terminal.output.write(lang.get(2));

        return true;

    };

    /**
     * Returns state to default. This will cause recoil all saved history, autocomplete to default and page reload.
     */
    this.resetState = function() {

        server.submit(terminal.serverActions.RESET);
        storage.clear();
        settings.reset();
        location.reload();

    };

    this.favorites = new function() {

        var commands = {};

        /**
         * Add new favorite record.
         *
         * @param index
         * @param query
         */
        this.add = function(index, query) {
            commands[index] = query + "";
        };

        /**
         * Returns favorite command.
         *
         * @param index
         * @returns {string}
         */
        this.get = function(index) {
            index = Math.max(0, Math.min(index, 9));
            return commands[index];
        };

        this.export = function() {
            return {
                "!export:favorites": true,
                commands: commands
            };
        };

        this.import = function(favoritesImportObject) {
            if (!(typeof favoritesImportObject === "object" &&
                favoritesImportObject.hasOwnProperty("!export:favorites")) &&
                favoritesImportObject.commands) {
                log.write("Wrong object to import as favorites import object: ", favoritesImportObject);
                return;
            }
            commands = favoritesImportObject.commands;
        };

    };

    var handlers = { // private handling

        globalKeyDown: function(event) {

            if (!terminal.input.focused() && !hid.keyPressed(hid.keys.CTRL)) {
                dom.objects.input.focus();
            }

            if (terminal.input.keyAction(event)) {
                setTimeout(function(){
                    terminal.input.keyPress.call(terminal.input,event.keyCode);
                },1);
            }

        },

        inputKeyDown: function() {
            terminal.input.update();
        },

        inputClick: function() {
            terminal.input.update();
        },

        /**
         * Executes when terminal application is closed.
         */
        end: function() {

            if (settings.get_restoreSession()) {
                terminal.output.write(lang.get(8));
                terminal.saveState();
            }
            server.disconnect();

        }

    };

    this.handlers = { // public handling

        serverMessage: function(data) {

            var result = (typeof receiveDataHandler == "function")?receiveDataHandler.call(this,data):1;
            if (result !== false) terminal.processor.processServerData(data);

        }

    };

    this.processor = new function() {

        var CREATE_OUTPUT = false; // output for empty server clear I/O message handler

        /**
         * Processes data received from server.
         *
         * @param data
         */
        this.processServerData = function(data) {

            var possibleAction = data.charAt(0);

            if (possibleAction == terminal.clientActions.EXIT_CLEAR_IO && data.substr(1) == "exit") {
                terminal.output.freeStack(0);
                terminal.output.setTarget(dom.objects.output);
                terminal.output.markDownAll();
                terminal.mode = terminal.modes.LAST;
                CREATE_OUTPUT = false;
            } // exit clear IO

            data = parser.clearHTML(data);

            if (CREATE_OUTPUT) { // wait for next message
                var obj = terminal.output.forceWrite("",true);
                terminal.output.setTarget(obj);
                CREATE_OUTPUT = false;
            }

            switch (terminal.mode) {
                case terminal.modes.NORMAL: terminal.processor.performAction(data.charAt(0),data.substr(1)); break;
                case terminal.modes.CLEAR_IO: {
                    if (possibleAction == terminal.clientActions.READ_STRING ||
                        possibleAction == terminal.clientActions.READ_CHARACTER) {
                        if (possibleAction == terminal.clientActions.READ_CHARACTER) terminal.input.switchCharRead();
                        terminal.namespace.set("");
                    }
                    terminal.processor.write((settings.get_parseOutput())?parser.highlightHTML(data):data, true);
                } break;
                case terminal.modes.SQL: {
                    if (possibleAction == terminal.clientActions.ENTER_CLEAR_IO) {
                        terminal.processor.performAction(possibleAction,data.substr(1))
                    } else if ((possibleAction == terminal.clientActions.EXIT_CLEAR_IO)) {
                        // upper
                    } else terminal.processor.write((settings.get_parseOutput())?parser.highlightHTML(data):data);
                } break;
                default: terminal.processor.write(lang.get(9) + " " + terminal.mode + ": " + lang.get(10) + ":\n" + data);
            }

        };

        /**
         * Performs action under data.
         *
         * @param action {string}
         * @param data {string}
         */
        this.performAction = function(action,data) {

            switch (action) {
                case terminal.clientActions.OUTPUT: terminal.output.write(parser.prepareForOutputHTML(data,-1,1)); break;
                case terminal.clientActions.CHANGE_NAMESPACE: terminal.namespace.set(data); break;
                case terminal.clientActions.ENTER_CLEAR_IO: {
                    terminal.modes.LAST = terminal.mode;
                    CREATE_OUTPUT = true;
                    terminal.mode = terminal.modes.CLEAR_IO;
                } break;
                case terminal.clientActions.EXIT_CLEAR_IO: terminal.mode = terminal.modes.LAST; break;
                case terminal.clientActions.LOAD_AUTOCOMPLETE: {
                    server.requestAutocompleteFile(data || terminal.namespace.getCorrectFileName());
                } break;
                case terminal.clientActions.AUTHORIZATION_STATUS: {
                    if (!settings.get_cleanStartup()) {
                        terminal.output.write((data == "1")?lang.get(3):lang.get(5));
                    }
                    terminal.ready = true; // TERMINAL READY
                } break;
                case terminal.clientActions.WATCH: {
                    terminal.watches.watch(data.trim());
                } break;
                case terminal.clientActions.LOGIN_INFO: {
                    if (data.charAt(0) === "!") {
	                    terminal.output.write(lang.get(79) + " " + data.substr(1));
                    } else if (!settings.get_cleanStartup()) {
	                    terminal.output.write(lang.get(78) + " " + data);
                    }
                } break;
                default: {
                    log.write("Unrecognised action from server.");
                    terminal.output.write(data);
                }
            }

        };

        this.internal = {

            sql: function() {
                if (terminal.mode == terminal.modes.SQL){
                    terminal.namespace.update();
                    terminal.mode = terminal.modes.NORMAL;
                } else {
                    terminal.namespace.mask("SQL");
                    terminal.mode = terminal.modes.SQL;
                }
                terminal.output.write("<span class=\"info\">" + lang.get(11) + " " +
                    lang.get((terminal.mode == terminal.modes.SQL)?12:13) + "</span>");
            },

            help: function() {
                terminal.output.write(application.HELPBOX);
            },

            settings: function() {
                settings.openPanel();
            },

            autocomplete: function(regenerate) {
                server.submit(
                    terminal.serverActions.GENERATE_AUTOCOMPLETE,
                    ((regenerate==="new")?"1":"0"),
                    false
                );
            },

            clear: function() {
                dom.clearLogs();
            },

            save: function() {
                terminal.saveState();
            },

            load: function() {
                terminal.loadState();
            },

            reset: function() {
                terminal.resetState();
            },

            connect: function(url) {
                server.connect(url);
                terminal.output.write(lang.get(15));
            },

            disconnect: function() {
                server.disconnect();
            },

            reconnect: function() {
                server.disconnect();
                server.connect();
            },

            define: function(redefinition, definition) {
                if (!definition || !redefinition) {
                    terminal.output.write(lang.get(16) + " /define [definition] [redefinition]");
                    return;
                }
                terminal.definitions.add(definition,redefinition);
                terminal.output.write("<span class=\"info\">" + definition + "</span> " + lang.get(17) + " " +
                    "<span class=\"info\">" + redefinition + "</span>")
            },

            about: function() {
                server.submit(terminal.serverActions.EXECUTE, 'for i=0:0.2:$zpi*2 { for u=1:1:($zsin(i)*15 + 15) { w ' +
                    '" " } w "# " if (i=1.4) { w "CacheWebTerminal v' + application.version() + '" } elseif (i=1.6) {' +
                    ' w "'+lang.get(18)+' InterSystems Cache" } elseif (i=1.8) { w "by ZitRo" } elseif (i=4.4) { w "' +
                    lang.get(19) + '" } elseif (i=4.6) { w "'+lang.get(20)+': http://intersystems-ru.github.io/webterm' +
                    'inal" } elseif (i=4.8) { w "'+lang.get(21)+'" } elseif (i=5) { w "'+lang.get(22)+'..." } w ! h 0.04}');
            },

            siege: function(iterations,serverDelay) {
                if (typeof iterations == "undefined") { iterations = 120 }
                if (typeof serverDelay == "undefined") { serverDelay = 0.02 }
                var serverCommand = "for i=1:1:"+iterations+" {\n  set s = \"\"\n  write s,$CHAR(65+$RANDOM(26))\n" +
                    "  if ($RANDOM(5) = 0) { write \" \" }\n  h "+serverDelay+"\n}";

                terminal.input.set(serverCommand);
                terminal.input.submit();
                var startTime = new Date().getTime();
                var packages = 0;

                receiveDataHandler = function(data) {
                    packages++;
                    if (data.charAt(0) == terminal.clientActions.EXIT_CLEAR_IO) {
                        receiveDataHandler = null;
                        var timeDifference = new Date().getTime() - startTime;
                        terminal.output.freeStack(0);
                        terminal.output.write("<span class=\"info\"><br>"+lang.get(23)+": " +
                            timeDifference + "/" + (serverDelay*iterations*1000) + "ms ("+lang.get(25)+")" +
                            "<br>"+lang.get(24)+": "+packages+"</span>\n");
                    }
                    return true;
                }
            },

            tail: function(name) {
                if (!name) {
                    if (!terminal.watches.stopAll()) {
                        terminal.output.write(lang.get(26))
                    }
                    return;
                }
                server.submit(terminal.serverActions.WATCH, name);
            },

            favorite: function(code, slot) {
                if (!isNaN(code)) {
                    terminal.input.set(terminal.favorites.get(code));
                    terminal.input.moveCaretToEnd();
                    return;
                }
                if (!code) { terminal.output.write(lang.get(27)); return;}
                if (slot && slot > -1 && slot < 10) {
                    terminal.favorites.add(slot, code);
                    terminal.output.write(lang.get(28) + " " + slot + ".");
                } else terminal.output.write(lang.get(29))
            },

            watch: function(name) {
                terminal.processor.executeInternal("tail",[name]);
            },

            tip: function(flag) {
                terminal.output.write(application.getTips(!!(flag === "all")));
            },

            echo: function() {
                if (arguments.length == 0) {
                    arguments[0] = lang.get(30);
                    arguments.length = 1;
                }
                var s = "";
                for (var i = 0; i < arguments.length; i++) {
                    s += ((i !== 0)?"\n":"") + arguments[i];
                }
                server.submit(terminal.serverActions.ECHO, s);
            }

        };

        /**
         * Executes internal command with given arguments.
         *
         * @param command
         * @param args
         */
        this.executeInternal = function(command,args) {

            if (this.internal.hasOwnProperty(command)) {
                if (!args || !args[0]) args = [];
                this.internal[command].apply(this,args)
            } else terminal.output.write(lang.get(31) + ": " + command);

        };

        /**
         * Write data to output stack and. This stage will process any escape-sequences received from server.
         * TODO: process escape-sequences
         *
         * @param data {string}
         */
        this.write = function(data) {
            terminal.output.write(data);
        };

    };

    this.initialize = function() {

        if (!dom.initialize() || !settings.initialize()) {
            log.write("Unable to init terminal: dom fault.",dom.objects);
            return;
        }

        lang.initialize();
        storage.initialize();
        lang.setLanguage(settings.get_language());

        this.output.setTarget(dom.objects.output); // set standard output

        hid.bindKeyDown(document, handlers.globalKeyDown);
        hid.bindKeyDown(document, function(){ // 1ms wrapper: to get input value in handler without masturbation
            setTimeout(function(){handlers.inputKeyDown()},1);
        });
        hid.bindClick(dom.objects.input, handlers.inputClick);
        window.onbeforeunload = handlers.end;

        var serverURL = server.getDefaultServerURL();
        if (!settings.get_cleanStartup()) {
            this.output.write(lang.get(0));
            this.output.write(lang.get(1) + " " + serverURL + "...");
        }

        server.connect(serverURL);
        dom.remove(dom.objects.startupScript);

        this.input.clear(); // Clear histories caused by "back" page
        this.input.focus();
        this.input.update();

    };

    /**
     * Represents method to work with history
     */
    this.history = new function() {

        var history = [""], // history of all submitted commands. Starting with empty string
            current = 0; // current position in commandHistory

        /**
         * Gets history record by id.
         *
         * @param id
         * @returns {string}
         */
        this.getByID = function(id) {
            if (id < 0 || id > history.length - 1) return "";
            return history[id]
        };

        /**
         * Imports history from exported object.
         */
        this.import = function(historyObject) {
            if (!(historyObject && historyObject["!export:history"])) {
                log.write("Wrong history object to import.");
                return;
            }
            history = historyObject["history"];
            current = historyObject["current"];
            terminal.input.set(this.get());
        };

        /**
         * Extorts history to object.
         *
         * @returns {object}
         */
        this.export = function() {
            return {
                "!export:history": true,
                history: history,
                current: current
            }
        };

        /**
         * Saves text to current history.
         *
         * @param text
         */
        this.save = function(text) {
            history[current] = text;
        };

        /**
         * Creates new history record for current input.
         */
        this.add = function() {
            if (this.get() == "" || this.get() === this.getByID(current - 1)) return;
            current = history.length;
            history.push("");
        };

        /**
         * Seeks current history position to last.
         */
        this.moveToLast = function() {
            current = history.length - 1;
        };

        /**
         * Returns current history record.
         *
         * @returns {string}
         */
        this.get = function() {
            return history[current];
        };

        /**
         * Returns history record with increment. This method changes current work history field.
         *
         * @param increment
         * @returns {string}
         */
        this.load = function(increment) {

            current += increment || 0;
            if (current < 0) current = history.length-1;
            if (current >= history.length) current = 0;
            return history[current];

        }

    };

    this.autocompletion = new function() {

        var variants = {},
            current = 0,
            number = 0,
            part = "";

        // sorts variants in decreasing order
        this.sortVariants = function() {

            var sorted = {}, array = [];

            for (var key in variants) {
                if (!variants.hasOwnProperty(key)) continue;
                array.push(variants[key]);
            }

            array.sort(function(a, b){
                return (a === b)?0:(a.p > b.p)?-1:1;
            });

            for (var i = 0; i < array.length; i++) {
                sorted[array[i].part] = array[i];
            }

            variants = sorted;

        };

        /**
         * Gets updates autocompletion for given arguments. By default method will work with terminal input and will
         * update current autocomplete.
         *
         * Variant object: {
         *   <variant short name>: {
         *     full: <fullname>,
         *     origin: {
         *       <reference to original autocomplete object>
         *     },
         *     p: <sort order>
         *   }
         * }
         *
         * See parser->getAutocomplete.part for more details.
         *
         * [ @param position ]
         *  Position where to check.
         * [ @param string ]
         *  String to check.
         */
        this.reset = function(position,string) {
            if (typeof position == "undefined") position = terminal.input.caretPosition();
            if (typeof string == "undefined") string = terminal.input.get();
            var vars = parser.getAutocomplete(string,position);
            variants = vars.data;
            number = vars.length;
            this.sortVariants();
            part = this.get(current = 0);
            return part;
        };

        /**
         * Mark given variant value in tree. (most-used)
         */
        this.chooseCurrent = function() {

            var i = 0;
            for (var currentName in variants) {
                if (i === current) {
                    if (!variants.hasOwnProperty(currentName)) continue;
                    try {
                        if (typeof variants[currentName]["origin"][variants[currentName]["full"]] === "number") {
                            variants[currentName]["origin"][variants[currentName]["full"]]++; // by reference
                        } else {
                            if (!variants[currentName]["origin"][variants[currentName]["full"]].hasOwnProperty("!p"))
                                continue;
                            variants[currentName]["origin"][variants[currentName]["full"]]["!p"]++; // by reference
                        }
                    } catch (e) {
                        log.write("Can't mark current autocomplete: check given object.",variants[currentName]);
                    }
                    break;
                }
                i++;
            }

        };

        /**
         * Returns if some variants aviable.
         *
         * @returns {boolean}
         */
        this.hasVariants = function() {
            return number != 0;
        };

        /**
         * Returns next autocomplete variant.
         *
         * @returns {string}
         */
        this.next = function() {
            if (this.hasVariants()) {
                part = this.get(current+1);
                return part;
            } else {
                part = "";
                return part;
            }
        };

        /**
         * Returns previous autocomplete variant.
         *
         * @returns {string}
         */
        this.previous = function() {
            if (this.hasVariants()) {
                part = this.get(current-1);
                return part;
            } else {
                part = "";
                return part;
            }
        };

        /**
         * Get variant by it's index in current variants. Note that index can handle any integer
         *
         * @param index
         * @returns {string}
         */
        this.get = function(index) {

            if (index < 0) index += number
            index = index % number;

            var i = 0, name = "";
            for (var currentName in variants) {
                if (i === index) {
                    name = currentName;
                    break;
                }
                i++;
            }

            current = index;
            return name;

        };

        /**
         * Clears all variants.
         */
        this.clear = function() {
            variants = {};
            current = 0;
            number = 0;
            part = "";
        };

        /**
         * Show variant to the user.
         */
        this.getSuggestion = function() {
            if (this.hasVariants()) {
                return this.get(current);
            } else return "";
        };

    };

    this.definitions = new function() {

        var definitions = {
            // "#1": "##class(My.Class)"
        };

        this.add = function(definition,redefinition) {
            definitions[definition] = redefinition;
            terminal.language.tokens["definitions"][definition] = 0;
        };

        this.remove = function(definition) {
            if (definitions.hasOwnProperty(definition)) {
                delete definitions[definition];
            } else log.write(definition + " not defined and cannot be removed.")
        };

        /**
         * Replaces all definitions in string.
         *
         * @param string
         */
        this.replace = function(string) {
            for (var def in definitions) {
                if (!definitions.hasOwnProperty(def)) continue;
                string = string.replace(def,definitions[def]);
            }
            return string;
        };

        this.export = function() {
            return {
                "!export:definitions": true,
                definitions: definitions
            };
        };

        this.import = function(languageImportObject) {
            if (!(typeof languageImportObject === "object" &&
                languageImportObject.hasOwnProperty("!export:definitions")) &&
                languageImportObject.definitions) {
                log.write("Wrong object to import as definitions import object: ", languageImportObject);
                return;
            }
            definitions = languageImportObject.definitions;
        };

    };

    this.watches = new function() {

        var watches = {

            },
            intervalID = -1,
            interval = 1000,
            check = function() {
                if (terminal.mode === terminal.modes.CLEAR_IO ||
                    terminal.mode === terminal.modes.SQL) return;
                try {
                    server.submit(terminal.serverActions.CHECK_WATCH)
                } catch (e) {
                    clearInterval(intervalID);
                    intervalID = -1;
                    terminal.output.write(lang.get(32))
                }
            };

        this.getWatches = function() { return watches };

        /**
         * Server handler for watch start/stop.
         *
         * @param name
         */
        this.watch = function(name) {
            if (name.charAt(0) == "!") {
                terminal.output.write(lang.get(33) + " " + name.substr(1));
                return;
            }
            var type = (name.charAt(0) === "^")?"global":"file";
            if (watches.hasOwnProperty(name)) {
                for(var prop in watches) {
                    if (!watches.hasOwnProperty(prop)) continue;
                    var props = true; break;
                }
                if (props) {
                    clearInterval(intervalID);
                    intervalID = -1;
                }
                delete watches[name];
                terminal.output.write(lang.get(34) + " " + name);
            } else {
                watches[name] = {
                    type: type
                };
                if (intervalID === -1) intervalID = setInterval(check, interval);
                terminal.output.write(lang.get(35) + " " + name);
            }
        };

        /**
         * Stops all watches. Returns true if at least one watch had been stopped.
         *
         * @returns {boolean}
         */
        this.stopAll = function() {
            var stop = false;
            for (var watch in watches) {
                if (!watches.hasOwnProperty(watch)) continue;
                stop = true;
                this.watch(watch);
            }
            return stop;
        };

    };

    // represents output and anything related to it
    this.output = new function() {

        var stack = "",
            target = null,
            lastID = 0,
            mark = false,
            escapeCharactersProcessing = false;

        var STACK_REFRESH_INTERVAL = 25;

        /**
         * Writes text to output as standalone message. If oldOutput defined, write will be forced to old output object.
         * Optional processEscape parameter will turn on escape characters processing for current output. This option
         * will be automatically turned off in case of any call of forceWrite function (turning once for current stack).
         * Also escape characters processing are unavailable for forceWrite call. To process escape-characters, set
         * html-container as a field of output, then perform forceWrite once with empty body, and then use write with
         * processEscape flag.
         *
         * @param text {string}
         * [ @param processEscape {boolean} ]
         */
        this.write = function(text, processEscape) {
            escapeCharactersProcessing = (processEscape)?true:false;
            if (target == dom.objects.output) {
                this.forceWrite(text);
            } else {
                stack += text;
            }
        };

        /**
         * Sets output target to object.
         *
         * @param object
         * @returns {boolean}
         */
        this.setTarget = function(object) {
            target = object;
            return true;
        };

        /**
         * Marks down all marked log headers.
         */
        this.markDownAll = function() {
            if (mark == false) dom.performForClassObjects("waiting",function(){
                this.className = this.className.replace(/waiting/g,"complete")
            });
        };

        this.processEscapeBlock = function() {

        };

        /**
         * Writing output to object immediately.
         *
         * @param text
         * [ @param marking ]
         *  Shows if it needed to mark log as "executing". Mark will still continue until another force write call.
         * @return {object}
         *  Object to output to.
         */
        this.forceWrite = function(text,marking) {

            if (typeof marking == "undefined") marking = false;
            escapeCharactersProcessing = false;

            var div = document.createElement("div");
            div.id = "terminal-log-"+lastID++;
            div.className = "terminal-outputContainer animated01";
            if (marking) {
                div.style.opacity = "0";
            }

            var head = document.createElement("div");
            head.className = "terminal-message-head"+((marking)?" waiting":"");
            head.innerHTML = terminal.namespace.getMask();

            var body = document.createElement("div");
            body.className = "terminal-message-body terminal-output-body";
            body.innerHTML = text;

            div.appendChild(head);
            div.appendChild(body);
            target.appendChild(div);
            setTimeout(function(){div.style.opacity = "1";},1);

            dom.scrollBottom();

            return body;

        };

        this.freeStack = function(highlight) {
            if (!stack) return;

            if (settings.get_animations()) {
                var el = document.createElement("span");
                el.className = "animated01";
                el.innerHTML = (highlight)?parser.highlightHTML(stack):stack;
                el.style.opacity = "0";
                setTimeout(function(){ el.style.opacity = "1" }, 1);
                target.appendChild(el);
            } else {
                target.innerHTML += stack;
            }

            dom.scrollBottom();
            stack = "";
        };

        setInterval(this.freeStack,STACK_REFRESH_INTERVAL); // refreshing output

    };

    // represents input and anything related to it
    this.input = new function() {

        var readChar = false;

        /**
         * Updates main input field view, highlights and redraws area.
         */
        this.update = function() {
            var data = terminal.input.get();
            var cp = (this.focused())?terminal.input.caretPosition():-1;
            dom.objects.inputView.innerHTML =
                parser.prepareForOutputHTML(data,cp,1,1);
            dom.scrollBottom();
        };

        /**
         * Returns true while input element in dom under focus.
         *
         * @returns {boolean}
         */
        this.focused = function() {
            return (document.activeElement == dom.objects.input);
        };

        /**
         * Sets the caret position to position.
         *
         * @param position {number}
         */
        this.setCaretPosition = function(position) {
            var element = dom.objects.input;
            if(element.createTextRange) {
                var range = element.createTextRange();
                range.move("character", position);
                range.select();
            } else {
                if(element.selectionStart) {
                    element.focus();
                    element.setSelectionRange(position, position);
                } else {
                    element.focus();
                }
            }
        };

        /**
         * Places caret at end of input.
         */
        this.moveCaretToEnd = function() {
            this.setCaretPosition(this.get().length)
        };

        /**
         * Inserts string to position without problems with caret position.
         *
         * @param position {number}
         * @param string {string}
         */
        this.insert = function(position, string) {

            var insert = function(position, to, string) {
                    return to.splice(position,0,string);
                },
                seek = 0;

            if (this.focused()) {
                var p = this.caretPosition();
                seek = (position <= p)?string.length:0;
                this.set(insert(position,this.get(),string));
                this.setCaretPosition(p+seek);
            } else this.set(insert(position,this.get(),string));

            this.update();

        };

        /**
         * Returns input value.
         *
         * @returns {string}
         */
        this.get = function() {
            return dom.objects.input.value;
        };

        /**
         * Clears input.
         */
        this.clear = function() {
            dom.objects.input.value = "";
            this.update();
        };

        /**
         * Returns current caret position
         *
         * @returns {number}
         */
        this.caretPosition = function() {
            return dom.objects.getCaretPosition(dom.objects.input);
        };

        /**
         * Clears input and causes it to read one character instead of anything else.
         */
        this.switchCharRead = function() {
            this.clear();
            readChar = true;
        };

        /**
         * Focuses on input field.
         */
        this.focus = function() {
            dom.objects.input.focus();
        };

        /**
         * Returns line where caret placed.
         *
         * @returns {number}
         */
        this.caretLine = function() {
            var caretPos = this.caretPosition();
            var data = this.get();
            var np = data.indexOf("\n");
            var line = 1;
            while (np != -1) {
                if (caretPos <= np) break;
                line++;
                np = data.indexOf("\n",np+1);
            }
            return line;
        };

        /**
         * Returns number of lines in input.
         *
         * @returns {number}
         */
        this.lines = function() {
            var arr = this.get().match(/\n/g);
            if (!arr) return 1;
            return arr.length + 1;
        };

        /**
         * Searches for client-side command in string and tries to execute it.
         *
         * @param query
         * @returns {boolean}
         */
        var tryClientCommand = function(query) {
            var arr = query.match(/("[^"]*")|[^\s"]+/g);
            if (!arr) return false;
            for (var i = 0; i < arr.length; i++) {
                if (/^\/[a-z]+$/.test(arr[i])) {
                    var command = arr[i].substr(1);
                    arr.splice(0, i + 1);
                    var fish = query.substring(0,query.indexOf("/" + command) - 1); // mm, fish
                    for (var u = 0; u < arr.length; u++) {
                        arr[u] = arr[u].replace(/"/g,"");
                    }
                    if (fish !== "") arr.splice(0, 0, fish);
                    terminal.processor.executeInternal(command, arr);
                    return true;
                }
            }
            return false;
        };

        /**
         * Submits current input data with, maybe, another action.
         *
         * [ @param action ]
         */
        this.submit = function(action) {

            if (typeof action == "undefined" || !action) {
                action = terminal.serverActions.EXECUTE;
                switch (terminal.mode) {
                    case terminal.modes.NORMAL: action = terminal.serverActions.EXECUTE; break;
                    case terminal.modes.SQL: action = terminal.serverActions.EXECUTE_SQL; break;
                    case terminal.modes.CLEAR_IO: action = ""; break;
                }
            }

            var data = terminal.input.get();

            if (action == terminal.serverActions.EXECUTE) {
                terminal.language.parseForTokens(data);
            }

            terminal.history.moveToLast();
            terminal.history.save(data);
            terminal.history.add();
            terminal.input.clear();

            if (!tryClientCommand(data)) {

                data = terminal.definitions.replace(data);
                server.submit(action,data);
                terminal.output.write(parser.prepareForOutputHTML(data));

            }

            terminal.autocompletion.clear();
            if (terminal.mode != terminal.modes.SQL) terminal.namespace.update();

        };

        /**
         * Sets the input value.
         *
         * @param value
         */
        this.set = function(value) {
            dom.objects.input.value = value;
        };

        /**
         * This function handles keypress moment. Returns false if keyAction was blocked or handled. False will not
         * call keyPress event.
         *
         * @param event
         */
        this.keyAction = function(event) {

            var key = event.keyCode || 0;

            if (readChar) {
                readChar = false;
                server.submit("",String.fromCharCode(key),true);
                terminal.output.write(String.fromCharCode(key));
                hid.preventDefault(event);
                this.clear();
                return false;
            }

            if (key == hid.keys.ENTER && !(hid.keyPressed(hid.keys.SHIFT) || hid.keyPressed(hid.keys.CTRL))) {
                hid.preventDefault(event);
                setTimeout(this.submit,1);
                return false;
            }

            if (key == hid.keys.ESC) {
                settings.closePanel();
            }

            if (key == hid.keys.UP || key == hid.keys.DOWN) {
                var line = this.caretLine();
                if ((key == hid.keys.UP && line == 1) ||
                    (key == hid.keys.DOWN && (line + ((key == hid.keys.DOWN)?1:0))) == this.lines() + 1) {
                    this.set(terminal.history.load( (key == hid.keys.UP)?-1:1 ));
                    hid.preventDefault(event);
                    terminal.input.moveCaretToEnd();
                    return false;
                }
            }

            if (key == hid.keys.TAB) {
                var variant = terminal.autocompletion.getSuggestion();
                if (variant) {
                    terminal.autocompletion.chooseCurrent();
                    terminal.autocompletion.clear();
                    this.insert(this.caretPosition(),variant);
                } else {
                    this.insert(this.caretPosition(),"\t");
                }
                hid.preventDefault(event);
                return false;
            }

            if (key == hid.keys.ALT) {
                hid.preventDefault(event);
                return true;
            }

            return true;

        };

        /**
         * This function handles post-keypress moment, when input text had been updated.
         *
         * @param key {number}
         */
        this.keyPress = function(key) {

            if (!hid.functional(key) || key == hid.keys.BACKSPACE) {
                terminal.autocompletion.reset();
            }

            if (terminal.autocompletion.hasVariants()) {
                if (key == hid.keys.CTRL) {
                    terminal.autocompletion.next();
                } else if (key == hid.keys.ALT) {
                    terminal.autocompletion.previous();
                }
            }

        }

    };

    this.namespace = new function() {

        var namespace = lang.get(4),
            oldNamespace = namespace;

        /**
         * Set current namespace. Namespace won't change if something unless string will be passed.
         */
        this.set = function(string) {
            if (!string){
                dom.objects.namespace.style.visibility = "hidden";
            } else {
                namespace = (typeof string == "string")?string:namespace;
                dom.objects.namespace.style.visibility = "visible";
            }
            dom.objects.namespace.innerHTML = namespace;
            oldNamespace = namespace;
        };

        /**
         * Creates a mask for terminal namespace. It's just for a view - namespace.get() will return normal namespace.
         *
         * @param string
         */
        this.mask = function(string) {
            namespace = string;
            dom.objects.namespace.innerHTML = namespace;
        };

        /**
         * Get current real namespace
         *
         * @returns {string}
         */
        this.get = function() {
            return oldNamespace; // not masked namespace
        };

        /**
         * Get current visible namespace.
         *
         * @returns {string}
         */
        this.getMask = function() {
            return namespace;
        };

        /**
         * Returns server correct namespace for filenames.
         *
         * @returns {string}
         */
        this.getCorrectFileName = function() {
            return this.get().replace("%","_");
        };

        /**
         * Sets namespace to current.
         */
        this.update = function() {
            namespace = oldNamespace;
            this.set(namespace);
        }

    };

    /**
     * Terminal language object. This one used in autocomplete.
     *
     * Object consists of other objects which determines program language. That's no meter how to call first-level
     * objects of [tokens] - that's just for perception. Language units must have properties of type number, which
     * determines importance of language unit usage. Properties beginning with the symbol "!" are the control
     * properties. They determining extra rules for language unit. Functionality of this properties is the next:
     *  "!autocomplete": reversed regular expression for autocomplete. Note the follow:
     *      -   To search unit in any position join ".*" to the end of expression. There's no meter to add this if you
     *          expecting unit to be placed at the beginning of string, such as system commands.
     *      -   Insert brackets to regular expression in position which have to match with properties (language units)
     *      -   Do not forget to write REVERSED regular expression for your expectations.
     */
    this.language = new function() {

        /**
         * Inserts new class definition.
         *
         * @param name
         * @param classToken
         */
        this.addClass = function(name,classToken) { // adds class to tokens

            if (typeof classToken == "object") {

                var merging = !this.tokens.class.hasOwnProperty(name);

                if (merging) {
                    this.tokens.class[name] = classToken;
                } else {
                    this.tokens.class[name].merge(classToken);
                }

            } else {

                log.write("Trying to add incorrect class to terminal language classes: ",classToken);

            }

        };

        /**
         * Inserts new global definition.
         *
         * @param name
         * @param globalToken
         */
        this.addGlobal = function(name,globalToken) { // adds class to tokens

            if (typeof name === "string") {

                if (!this.tokens.global.hasOwnProperty(name)) {
                    this.tokens.global[name] = globalToken;
                } else {
                    this.tokens.global[name].merge(globalToken);
                }

            } else {

                log.write("Trying to add incorrect global to terminal language classes: ", globalToken);

            }

        };

        /**
         * Add a set of classes placed in classTokens objects
         *
         * @param classTokens
         */
        this.addClasses = function(classTokens) {

            if (typeof classTokens != "object") {
                log.write("language.addClasses error: argument is not an object.")
            }
            for (var property in classTokens) {
                if (!classTokens.hasOwnProperty(property)) continue;
                this.addClass(property,classTokens[property]);
            }

        };

        /**
         * Add a set of globals in globalTokens objects
         *
         * @param globalsTokens
         */
        this.addGlobals = function(globalsTokens) {

            if (typeof globalsTokens != "object") {
                log.write("language.addGlobals error: argument is not an object.")
            }
            for (var property in globalsTokens) {
                if (!globalsTokens.hasOwnProperty(property)) continue;
                this.addGlobal(property,globalsTokens[property]);
            }

        };

        this.export = function() {
            return {
                "!export:language": true,
                tokens: this.tokens
            };
        };

        this.import = function(languageImportObject) {
            if (!(typeof languageImportObject === "object" &&
                languageImportObject.hasOwnProperty("!export:language")) &&
                languageImportObject.tokens) {
                log.write("Wrong object to import as language import object: ", languageImportObject);
                return;
            }
            this.tokens = languageImportObject.tokens;
        };

        /**
         * Creates user's language token for name.
         *
         * @param name
         */
        this.joinUserToken = function(name) {
            var r = new RegExp("[a-zA-Z][a-zA-Z0-9]*");
            if (!r.test(name)) {
                log.write("Wrong user token " + name);
                return;
            }
            if (!this.tokens.user.hasOwnProperty(name)) {
                this.tokens.user[name] = 0
            }
        };

        /**
         * Creates user's language token for name.
         *
         * @param name
         */
        this.removeUserToken = function(name) {
            if (name === "*") {
                for (var t in this.tokens.user) {
                    if (!this.tokens.user.hasOwnProperty(t) || t.charAt(0) === "!") continue;
                    delete this.tokens.user[t];
                }
                return;
            }
            var r = new RegExp("[a-zA-Z][a-zA-Z0-9]*");
            if (!r.test(name)) {
                log.write("Wrong user token " + name);
                return;
            }
            if (this.tokens.user.hasOwnProperty(name)) {
                delete this.tokens.user[name]
            }
        };

        /**
         * Finds in string required tokens and adds/removes it to/from Cache language.
         * E.g. "set test = 12" or "s test = 12" will add "test" to tokens.user, and
         * "kill test" or "k test" will remove "test" token.
         *
         * @param string
         */
        this.parseForTokens = function(string) {

            string = " " + string + "  "; // keep two spaces
            var re = new RegExp("[\\s\\{](set|s)\\s(([a-zA-Z][a-zA-Z0-9]*)|(\\^[a-zA-Z][a-z\\.A-Z0-9]*))\\s*=","ig"),
                result = re.exec(string);
            if (result && result[2]) {
                if (result[2].charAt(0) === "^") {
                    this.tokens.global[result[2].substr(1)] = 0;
                } else {
                    this.joinUserToken(result[2]);
                }
            }

            re = new RegExp("[\\s\\{](k|kill)\\s(([a-zA-Z][a-zA-Z0-9]*)|(\\^[a-zA-Z][a-z\\.A-Z0-9]*))[\\s\\}]","ig");
            result = re.exec(string);
            if (result && result[2]) {
                if (result[2].charAt(0) === "^" && this.tokens.global.hasOwnProperty(result[2].substr(1))) {
                    delete this.tokens.global[result[2].substr(1)];
                } else this.removeUserToken(result[2]);
            }

            re = new RegExp("[\\s\\{](k|kill)[\\s]+?[^a-zA-Z]","ig");
            result = re.exec(string);
            if (result && result[1]) {
                this.removeUserToken("*");
            }

        };

        /**
         * Tokens language object. RULES:
         *  Autocomplete parsing will be performed for any object in {tokens} which has "!autocomplete" property and
         *  reversedRegExp property inside. There are two optional parameters:
         *      separator (no default) - brakes autocomplete variants by parts. For example, it can be point symbol "."
         *      caseSensitive (true) - makes variants case-sensitive. Make sure that non-sensitive variants defined as
         *          lowercase.
         *      child (no default) - parse autocomplete for child. In this case properties of current object have to be
         *          objects with the same structure as parent. {child} also can have reversedRegExp, which will stand as
         *          a postfix for parent regular expression.
         *
         *  reversedRegExp MUST have at least one pair of remembering parentheses - this where parser will search
         *  matches.
         */
        this.tokens = {

            "user": {
                "!autocomplete": {
                    reversedRegExp: "([a-zA-Z]+)\\s"
                }
            },
            "definitions": {
                "!autocomplete": {
                    reversedRegExp: "([^\\s]+)\\s.*"
                }
            },
            "client": {
                "!autocomplete": {
                    reversedRegExp: "([a-z]*/)+"
                },
                "/help": 1,
                "/clear": 0,
                "/connect": 0,
                "/disconnect": 0,
                "/reset": 0,
                "/reconnect": 0,
                "/autocomplete": 0,
                "/save": 0,
                "/load": 0,
                "/settings": 0,
                "/siege": 0,
                "/define": 0,
                "/tail": 0,
                "/favorite": 0,
                "/watch": 0,
                "/tip": 1,
                "/echo": 0
            },
            "commands": {
                "!autocomplete": {
                    reversedRegExp: "([a-zA-Z]+)\\s.*",
                    caseSensitive: false
                },
                "break": 0,
                "catch": 0,
                "close": 0,
                "continue": 0,
                "do": 0,
                "d": 0,
                "else": 0,
                "elseif": 0,
                "for": 0,
                "goto": 0,
                "halt": 0,
                "hang": 0,
                "h": 0,
                "if": 0,
                "job": 0,
                "j": 0,
                "kill": 0,
                "k": 0,
                "lock": 0,
                "l": 0,
                "merge": 0,
                "new": 0,
                "open": 0,
                "quit": 0,
                "q": 0,
                "read": 0,
                "r": 0,
                "return": 0,
                "set": 0,
                "s": 0,
                "tcommit": 0,
                "throw": 0,
                "trollback": 0,
                "try": 0,
                "tstart": 0,
                "use": 0,
                "view": 0,
                "while": 0,
                "write": 0,
                "w": 0,
                "xecute": 0,
                "x": 0,
                "zkill": 0,
                "znspace": 0,
                "zn": 0,
                "ztrap": 0,
                "zwrite": 0,
                "zw": 0,
                "zzdump": 0,
                "zzwrite": 0,

                "print": 0,
                "zbreak": 0,
                "zinsert": 0,
                "zload": 0,
                "zprint": 0,
                "zremove": 0,
                "zsave": 0,
                "zzprint": 0,

                "mv": 0,
                "mvcall": 0,
                "mvcrt": 0,
                "mvdim": 0,
                "mvprint": 0,
                "zquit": 0,
                "zsync": 0
            },
            "functions": {
                "!autocomplete": {
                    reversedRegExp: "([a-zA-Z]+)\\$\\s.*",
                    caseSensitive: false
                },
                "ascii": 0,
                "bit": 0,
                "bitcount": 0,
                "bitfind": 0,
                "bitlogic": 0,
                "case": 0,
                "char": 0,
                "classmethod": 0,
                "classname": 0,
                "compile": 0,
                "data": 0,
                "decimal": 0,
                "double": 0,
                "extract": 0,
                "factor": 0,
                "find": 0,
                "fnumber": 0,
                "get": 0,
                "increment": 0,
                "inumber": 0,
                "isobject": 0,
                "isvaliddouble": 0,
                "isvalidnum": 0,
                "justify": 0,
                "length": 0,
                "list": 0,
                "listbuild": 0,
                "listdata": 0,
                "listfind": 0,
                "listfromstring": 0,
                "listget": 0,
                "listlength": 0,
                "listnext": 0,
                "listsame": 0,
                "listtostring": 0,
                "listvalid": 0,
                "locate": 0,
                "match": 0,
                "method": 0,
                "name": 0,
                "nconvert": 0,
                "next": 0,
                "normalize": 0,
                "now": 0,
                "number": 0,
                "order": 0,
                "parameter": 0,
                "piece": 0,
                "prefetchoff": 0,
                "prefetchon": 0,
                "property": 0,
                "qlength": 0,
                "qsubscript": 0,
                "query": 0,
                "random": 0,
                "replace": 0,
                "reverse": 0,
                "sconvert": 0,
                "select": 0,
                "sortbegin": 0,
                "sortend": 0,
                "stack": 0,
                "text": 0,
                "translate": 0,
                "view": 0,
                "wascii": 0,
                "wchar": 0,
                "wextract": 0,
                "wfind": 0,
                "wiswide": 0,
                "wlength": 0,
                "wreverse": 0,
                "xecute": 0,

                "zabs": 0,
                "zarccos": 0,
                "zarcsin": 0,
                "zarctan": 0,
                "zcos": 0,
                "zcot": 0,
                "zcsc": 0,
                "zdate": 0,
                "zdateh": 0,
                "zdatetime": 0,
                "zdatetimeh": 0,
                "zexp": 0,
                "zhex": 0,
                "zln": 0,
                "zlog": 0,
                "zpower": 0,
                "zsec": 0,
                "zsin": 0,
                "zsqr": 0,
                "ztan": 0,
                "ztime": 0,
                "ztimeh": 0,

                "zboolean": 0,
                "zconvert": 0,
                "zcrc": 0,
                "zcyc": 0,
                "zdascii": 0,
                "zdchar": 0,
                "zf": 0,
                "ziswide": 0,
                "zlascii": 0,
                "zlchar": 0,
                "zname": 0,
                "zposition": 0,
                "zqascii": 0,
                "zqchar": 0,
                "zsearch": 0,
                "zseek": 0,
                "zstrip": 0,
                "zwascii": 0,
                "zwchar": 0,
                "zwidth": 0,
                "zwpack": 0,
                "zwbpack": 0,
                "zwunpack": 0,
                "zwbunpack": 0,
                "zzenkaku": 0,

                "change": 0,
                "mv": 0,
                "mvat": 0,
                "mvfmt": 0,
                "mvfmts": 0,
                "mviconv": 0,
                "mviconvs": 0,
                "mvinmat": 0,
                "mvlover": 0,
                "mvoconv": 0,
                "mvoconvs": 0,
                "mvraise": 0,
                "mvtrans": 0,
                "mvv": 0,
                "mvname": 0,

                "zbitand": 0,
                "zbitcount": 0,
                "zbitfind": 0,
                "zbitget": 0,
                "zbitlen": 0,
                "zbitnot": 0,
                "zbitor": 0,
                "zbitset": 0,
                "zbitstr": 0,
                "zbitxor": 0,
                "zincrement": 0,
                "znext": 0,
                "zorder": 0,
                "zprevious": 0,
                "zsort": 0
            },
            "variables": {
                "!autocomplete": {
                    reversedRegExp: "([a-zA-Z]+)\\$\\s.*",
                    caseSensitive: false
                },
                "device": 0,
                "ecode": 0,
                "estack": 0,
                "etrap": 0,
                "halt": 0,
                "horolog": 0,
                "io": 0,
                "job": 0,
                "key": 0,
                "namespace": 0,
                "principal": 0,
                "quit": 0,
                "roles": 0,
                "stack": 0,
                "storage": 0,
                "system": 0,
                "test": 0,
                "this": 0,
                "tlevel": 0,
                "username": 0,
                "x": 0,
                "y": 0,
                "za": 0,
                "zb": 0,
                "zchild": 0,
                "zeof": 0,
                "zeos": 0,
                "zerror": 0,
                "zhorolog": 0,
                "zio": 0,
                "zjob": 0,
                "zmode": 0,
                "zname": 0,
                "znspace": 0,
                "zorder": 0,
                "zparent": 0,
                "zpi": 0,
                "zpos": 0,
                "zreference": 0,
                "zstorage": 0,
                "ztimestamp": 0,
                "ztimezone": 0,
                "ztrap": 0,
                "zversion": 0
            },
            "staticMethod": {
                "!autocomplete": {
                    reversedRegExp: "([a-zA-Z]*##)\\s.*"
                },
                "##class": 0
            },
            "class": {
                "!autocomplete": {
                    reversedRegExp: "(([a-zA-Z\\.]*[a-zA-Z])?%?)\\(ssalc##\\s.*",

                    separator: ".",
                    child: {
                        reversedRegExp: "([a-zA-Z]*%?)\\.\\)"
                    }
                }
            },
            "global": {
                "!autocomplete": {
                    reversedRegExp: "(([a-zA-Z0-9\\.]*[a-zA-Z]+)?%?)\\^.*",
                    separator: "."
                }
            }
        }; // tokens

    };

};]]></CSP>


<CSP name="WebTerminal/js/unit.js" application="/csp/sys/" default="1"><![CDATA[
/**
 * Provides unit tests for terminal application. Use unit.run() to run unit tests.
 */
var unit = new function() {

    var wrongs = 0,
        passed = 0;

    var write = function(text) {
        log.write(text);
    };

    var pass = function(value,expected,string,where) {
        if (value == expected) {
            passed += 1;
            string = "passed: [" + string + "] in " + where;
        } else {
            wrongs += 1;
            string = "wrong: [" + string + "] != " + value + " in " + where;
        }
        write(string);
    };

    var fullTest = {

        "parser.convertPositionForHTML": function(f,n) {

            var test = {
                0: { s: "test", p: 0, r: 0 },
                1: { s: "test", p: 3, r: 3 },
                2: { s: "test", p: -1, r: 0 },
                3: { s: "test", p: 100, r: 4 },
                4: { s: "a<tag>b", p: 0, r: 0 },
                5: { s: "a<tag>test", p: 7, r: 10 },
                6: { s: "a<tag>test", p: 6, r: 10 },
                7: { s: "a<tag>test", p: 2, r: 7 },
                8: { s: "a<tag>test", p: 6, r: 10 },
                9: { s: "a<tag>test", p: 4, r: 9 },
                10: { s: "a&nbsp;test", p: 1, r: 1 },
                11: { s: "a&nbsp;test", p: 2, r: 7 },
                12: { s: "a&nbsp;test", p: 5, r: 10 },
                13: { s: "a&nbsp;test", p: 6, r: 11 },
                14: { s: "a&nbsp;test", p: 7, r: 11 },
                15: { s: "a&nbsp;test", p: 9, r: 11 },
                16: { s: "I <a>a&nbsp;te</a>st", p: 5, r: 13 },
                17: { s: "I <a>a&nbsp;te</a>st", p: 6, r: 14 },
                18: { s: "I <a>a&nbsp;te</a>st", p: 8, r: 20 },
                19: { s: "I <a>a&nbsp;te</a>st", p: 12, r: 20 },
                20: { s: "I <a>a&nbsp;te</a>st", p: 15, r: 20 },
                21: { s: "I <a>a&nbsp;te</a>st", p: 17, r: 20 },
                22: { s: "I <a>a&nbsp;te</a>st", p: 18, r: 20 },
                23: { s: "I <a>a&nbsp;te</a>st", p: 19, r: 20 }
            };

            for (var t in test) {
                if (!test.hasOwnProperty(t)) continue;
                var o = test[t];
                pass(f(o.s, o.p), o.r, o.p + " in \""+ o.s +"\" gives " + o.r,n);
            }

        }

    };


    this.run = function() {
        wrongs = 0;
        passed = 0;
        for (var test in fullTest) {
            if (!fullTest.hasOwnProperty(test)) continue;
            if (typeof fullTest[test] == "function") {
                var f = eval(test);
                if (typeof f == "function") {
                    fullTest[test].call(this,f,test);
                } else {
                    pass(false,"wrong unit","unitTest.run");
                }
            }
        }
        log.write("Passed: " + passed + "/" + (passed + wrongs));
        log.write("Failed: " + wrongs);
        if (wrongs > 0) log.write("Application is wrong to deploy.");
    };

};]]></CSP>
</Export>