fix

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/.gitignore

@@ -0,0 +1,6 @@
+*.pyc
+*.o
+tests/data_*.js
+utils/rebind.so
+utils/websockify
+node_modules

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "include/web-socket-js-project"]
+	path = include/web-socket-js-project
+	url = https://github.com/gimite/web-socket-js.git

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/.travis.yml

@@ -0,0 +1,18 @@
+language: node_js
+node_js:
+- '0.11.13'
+env:
+  matrix:
+  - TEST_BROWSER_NAME=PhantomJS
+  - TEST_BROWSER_NAME=chrome TEST_BROWSER_OS='Windows 7,Linux'
+  - TEST_BROWSER_NAME=firefox TEST_BROWSER_OS='Windows 7,Linux' TEST_BROWSER_VERSION='30,26'
+  - TEST_BROWSER_NAME='internet explorer' TEST_BROWSER_OS='Windows 7' TEST_BROWSER_VERSION=10
+  - TEST_BROWSER_NAME='internet explorer' TEST_BROWSER_OS='Windows 8.1' TEST_BROWSER_VERSION=11
+  - TEST_BROWSER_NAME=safari TEST_BROWSER_OS='OS X 10.8' TEST_BROWSER_VERSION=6
+  - TEST_BROWSER_NAME=safari TEST_BROWSER_OS='OS X 10.9' TEST_BROWSER_VERSION=7
+  global:
+  - secure: QE5GqGd2hrpQsIgd8dlv3oRUUHqZayomzzQjNXOB81VQi241uz/ru+3GtBZLB5WLZCq/Gj89vbLnR0LN4ixlmPaWv3/WJQGyDGuRD/vMnccVl+rBUP/Hh2zdYwiISIGcrywNAE+KLus/lyt/ahVgzbaRaDSzrM1HaZFT/rndGck=
+  - secure: g75sdctEwj0hoLW0Y08Tdv8s5scNzplB6a9EtaJ2vJD9S/bK+AsPqbWesGv1UlrFPCWdbV7Vg61vkmoUjcmb5xhqFIjcM9TlYJoKWeOTsOmnQoSIkIq6gMF1k02+LmKInbPgIzrp3m3jluS1qaOs/EzFpDnJp9hWBiAfXa12Jxk=
+before_script: npm install -g karma-cli
+addons:
+  sauce_connect: true

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/CONTRIBUTING.md

@@ -0,0 +1,54 @@
+How to contribute to noVNC
+==========================
+
+We accept code via pull requests on GitHub.  There are several guidelines that
+we expect contributors submitting code requests to follow.  If you have issues
+following any of these guidelines, feel free to drop us a line by leaving a
+comment in the code request or sending us an email.
+
+Contributing Guidelines
+-----------------------
+
+* While we don't have an official coding style guide, please try to follow
+  the general coding style of the existing code.
+** Use four spaces instead of tabs 
+** prefix private variables and functions with an `_`
+
+* Please try to include unit tests for your code.  For instance, if you
+  introduce a new encoding, add a test to `tests/test.rfb.js` under the
+  "Encoding Handlers" section (basically, input a small pattern in your
+  encoding and make sure the pattern gets displayed correctly).  If you
+  fix a bug, try to add a unit test that would have caught that bug
+  (if possible -- some bugs, especially visual ones, are hard to test for).
+
+* Squash your commits down in to a clean commit history.  For instance, there
+  should not be "cleanup" commits where you fix issues in previous commits in
+  the same pull request.  Before you go to commit, use `git rebase -i` to
+  squash these changes into the relevant commits.  For instance, a good commit
+  history might look like "Added support for FOO encoding, Added support for
+  BAR message, Placed Button in UI to Trigger BAR" (where each comma denotes
+  a separate commit).
+
+* Add both a title and description to your commit, if possible.  Place more
+  detail on what you did in the description.
+
+Running the unit tests
+----------------------
+
+There are two ways to run the unit tests.  For both ways, you should first run
+`npm install` (not as root).
+
+The first way to run the tests is to run `npm test`.  This will run all the
+tests in the headless PhantomJS browser (which uses WebKit).
+
+The second way to run the tests is using the `tests/run_from_console.js` file.
+This way is a bit more flexible, and can provide more information about what
+went wrong.  To run all the tests, simply run `tests/run_from_console.js`.
+To run a specific test file, you can use the `-t path/to/test/file.js` option.
+If you wish to simply generate the HTML for the test, use the `-g` option, and
+the path to the temporary HTML file will be written to standard out.  To open
+this file in your default browser automatically, pass the `-o` option as well.
+More information can be found by passing the `--help` or `-h` option.
+
+
+Thanks, and happy coding!

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/LICENSE.txt

@@ -0,0 +1,82 @@
+noVNC is Copyright (C) 2011 Joel Martin <github@martintribe.org>
+
+The noVNC core library files are licensed under the MPL 2.0 (Mozilla
+Public License 2.0). The noVNC core library is composed of the
+Javascript code necessary for full noVNC operation. This includes (but
+is not limited to):
+
+    include/base64.js
+    include/des.js
+    include/display.js
+    include/input.js
+    include/jsunzip.js
+    include/keysym.js
+    include/logo.js
+    include/rfb.js
+    include/ui.js
+    include/util.js
+    include/vnc.js
+    include/websock.js
+    include/webutil.js
+
+The HTML, CSS, font and images files that included with the noVNC
+source distibution (or repository) are not considered part of the
+noVNC core library and are licensed under more permissive licenses.
+The intent is to allow easy integration of noVNC into existing web
+sites and web applications.
+
+The HTML, CSS, font and image files are licensed as follows:
+
+    *.html                     : 2-Clause BSD license
+
+    include/*.css              : 2-Clause BSD license
+
+    include/Orbitron*          : SIL Open Font License 1.1
+                                 (Copyright 2009 Matt McInerney)
+
+    images/                    : Creative Commons Attribution-ShareAlike
+                                 http://creativecommons.org/licenses/by-sa/3.0/
+
+Some portions of noVNC are copyright to their individual authors.
+Please refer to the individual source files and/or to the noVNC commit
+history: https://github.com/kanaka/noVNC/commits/master
+
+The are several files and projects that have been incorporated into
+the noVNC core library. Here is a list of those files and the original
+licenses (all MPL 2.0 compatible):
+
+    include/base64.js          : MPL 2.0
+   
+    include/des.js             : Various BSD style licenses
+
+    include/jsunzip.js         : zlib/libpng license
+
+    include/web-socket-js/     : New BSD license (3-clause). Source code at
+                                 http://github.com/gimite/web-socket-js
+
+    include/chrome-app/tcp-stream.js
+                               : Apache 2.0 license
+
+    utils/websockify
+    utils/websocket.py         : LGPL 3
+
+The following license texts are included:
+
+    docs/LICENSE.MPL-2.0
+    docs/LICENSE.LGPL-3 and
+    docs/LICENSE.GPL-3
+    docs/LICENSE.OFL-1.1
+    docs/LICENSE.BSD-3-Clause (New BSD)
+    docs/LICENSE.BSD-2-Clause (Simplified BSD / FreeBSD)
+    docs/LICENSE.zlib
+    docs/LICENSE.Apache-2.0
+
+Or alternatively the license texts may be found here:
+
+    http://www.mozilla.org/MPL/2.0/
+    http://www.gnu.org/licenses/lgpl.html and
+    http://www.gnu.org/licenses/gpl.html
+    http://scripts.sil.org/OFL
+    http://en.wikipedia.org/wiki/BSD_licenses
+    http://www.gzip.org/zlib/zlib_license.html
+    http://www.apache.org/licenses/LICENSE-2.0.html

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/README.md

@@ -0,0 +1,138 @@
+## noVNC: HTML5 VNC Client
+
+[![Build Status](https://travis-ci.org/kanaka/noVNC.svg?branch=master)](https://travis-ci.org/kanaka/noVNC)
+
+### Description
+
+noVNC is a HTML5 VNC client that runs well in any modern browser
+including mobile browsers (iPhone/iPad and Android).
+
+Many companies/projects have integrated noVNC including [Ganeti Web
+Manager](http://code.osuosl.org/projects/ganeti-webmgr),
+[OpenStack](http://www.openstack.org),
+[OpenNebula](http://opennebula.org/), and
+[LibVNCServer](http://libvncserver.sourceforge.net). See [the Projects
+and Companies wiki
+page](https://github.com/kanaka/noVNC/wiki/ProjectsCompanies-using-noVNC)
+for a more complete list with additional info and links.
+
+### News/help/contact
+
+Notable commits, announcements and news are posted to
+<a href="http://www.twitter.com/noVNC">@noVNC</a>
+
+If you are a noVNC developer/integrator/user (or want to be) please
+join the <a
+href="https://groups.google.com/forum/?fromgroups#!forum/novnc">noVNC
+discussion group</a>
+
+Bugs and feature requests can be submitted via [github
+issues](https://github.com/kanaka/noVNC/issues). If you are looking
+for a place to start contributing to noVNC, a good place to start
+would be the issues that are marked as
+["patchwelcome"](https://github.com/kanaka/noVNC/issues?labels=patchwelcome).
+
+If you want to show appreciation for noVNC you could donate to a great
+non-profits such as: [Compassion
+International](http://www.compassion.com/), [SIL](http://www.sil.org),
+[Habitat for Humanity](http://www.habitat.org), [Electronic Frontier
+Foundation](https://www.eff.org/), [Against Malaria
+Foundation](http://www.againstmalaria.com/), [Nothing But
+Nets](http://www.nothingbutnets.net/), etc. Please tweet <a
+href="http://www.twitter.com/noVNC">@noVNC</a> if you do.
+
+
+### Features
+
+* Supports all modern browsers including mobile (iOS, Android)
+* Supported VNC encodings: raw, copyrect, rre, hextile, tight, tightPNG
+* WebSocket SSL/TLS encryption (i.e. "wss://") support
+* 24-bit true color and 8 bit colour mapped
+* Supports desktop resize notification/pseudo-encoding
+* Local or remote cursor
+* Clipboard copy/paste
+* Clipping or scolling modes for large remote screens
+* Easy site integration and theming (3 example themes included)
+* Licensed under the [MPL 2.0](http://www.mozilla.org/MPL/2.0/)
+
+### Screenshots
+
+Running in Chrome before and after connecting:
+
+<img src="http://kanaka.github.com/noVNC/img/noVNC-5.png" width=400>&nbsp;<img src="http://kanaka.github.com/noVNC/img/noVNC-7.jpg" width=400>
+
+See more screenshots <a href="http://kanaka.github.com/noVNC/screenshots.html">here</a>.
+
+
+### Browser Requirements
+
+* HTML5 Canvas (with createImageData): Chrome, Firefox 3.6+, iOS
+  Safari, Opera 11+, Internet Explorer 9+, etc.
+
+* HTML5 WebSockets: For browsers that do not have builtin
+  WebSockets support, the project includes
+  <a href="http://github.com/gimite/web-socket-js">web-socket-js</a>,
+  a WebSockets emulator using Adobe Flash. iOS 4.2+ has built-in
+  WebSocket support.
+
+* Fast Javascript Engine: this is not strictly a requirement, but
+  without a fast Javascript engine, noVNC might be painfully slow.
+
+* See the more detailed [browser compatibility wiki page](https://github.com/kanaka/noVNC/wiki/Browser-support).
+
+
+### Server Requirements
+
+Unless you are using a VNC server with support for WebSockets
+connections (such as
+[x11vnc/libvncserver](http://libvncserver.sourceforge.net/),
+[QEMU](http://www.qemu.org/), or
+[PocketVNC](http://www.pocketvnc.com/blog/?page_id=866)), you need to
+use a WebSockets to TCP socket proxy. There is a python proxy included
+('websockify').
+
+
+### Quick Start
+
+* Use the launch script to start a mini-webserver and the WebSockets
+  proxy (websockify). The `--vnc` option is used to specify the location of
+  a running VNC server:
+
+    `./utils/launch.sh --vnc localhost:5901`
+
+* Point your browser to the cut-and-paste URL that is output by the
+  launch script. Enter a password if the VNC server has one
+  configured. Hit the Connect button and enjoy!
+
+
+### Other Pages
+
+* [Encrypted Connections](https://github.com/kanaka/websockify/wiki/Encrypted-Connections). How to setup websockify so that you can use encrypted connections from noVNC.
+
+* [Advanced Usage](https://github.com/kanaka/noVNC/wiki/Advanced-usage). Starting a VNC server, advanced websockify usage, etc.
+
+* [Integrating noVNC](https://github.com/kanaka/noVNC/wiki/Integration) into existing projects.
+
+* [Troubleshooting noVNC](https://github.com/kanaka/noVNC/wiki/Troubleshooting) problems.
+
+
+### Authors/Contributors
+
+* Core team:
+    * [Joel Martin](https://github.com/kanaka)
+    * [Samuel Mannehed](https://github.com/samhed) (Cendio)
+    * [Peter Åstrand](https://github.com/astrand) (Cendio)
+    * [Solly Ross](https://github.com/DirectXMan12) (Red Hat / OpenStack)
+
+* Notable contributions:
+    * UI and Icons : Chris Gordon
+    * Original Logo : Michael Sersen
+    * tight encoding : Michael Tinglof (Mercuri.ca)
+
+* Included libraries:
+    * web-socket-js : Hiroshi Ichikawa (github.com/gimite/web-socket-js)
+    * as3crypto : Henri Torgemane (code.google.com/p/as3crypto)
+    * base64 : Martijn Pieters (Digital Creations 2), Samuel Sieb (sieb.net)
+    * jsunzip : Erik Moller (github.com/operasoftware/jsunzip),
+    * tinflate : Joergen Ibsen (ibsensoftware.com)
+    * DES : Dave Zimmerman (Widget Workshop), Jef Poskanzer (ACME Labs)

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/favicon.ico

@@ -0,0 +1 @@
+images/favicon.ico

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/base.css

@@ -0,0 +1,518 @@
+/*
+ * noVNC base CSS
+ * Copyright (C) 2012 Joel Martin
+ * Copyright (C) 2013 Samuel Mannehed for Cendio AB
+ * noVNC is licensed under the MPL 2.0 (see LICENSE.txt)
+ * This file is licensed under the 2-Clause BSD license (see LICENSE.txt).
+ */
+
+body {
+  margin:0;
+  padding:0;
+  font-family: Helvetica;
+  /*Background image with light grey curve.*/
+  background-color:#494949;
+  background-repeat:no-repeat;
+  background-position:right bottom;
+  height:100%;
+}
+
+html {
+  height:100%;
+}
+
+#noVNC_controls ul {
+  list-style: none;
+  margin: 0px;
+  padding: 0px;
+}
+#noVNC_controls li {
+  padding-bottom:8px;
+}
+
+#noVNC_host {
+  width:150px;
+}
+#noVNC_port {
+  width: 80px;
+}
+#noVNC_password {
+  width: 150px;
+}
+#noVNC_encrypt {
+}
+#noVNC_path {
+  width: 100px;
+}
+#noVNC_connect_button {
+  width: 110px;
+  float:right;
+}
+
+#noVNC_buttons {
+  white-space: nowrap;
+}
+
+#noVNC_view_drag_button {
+  display: none;
+}
+#sendCtrlAltDelButton {
+  display: none;
+}
+#noVNC_xvp_buttons {
+  display: none;
+}
+#noVNC_mobile_buttons {
+  display: none;
+}
+
+#noVNC_extra_keys {
+  display: inline;
+  list-style-type: none;
+  padding: 0px;
+  margin: 0px;
+  position: relative;
+}
+
+.noVNC-buttons-left {
+  float: left;
+  z-index: 1;
+  position: relative;
+}
+
+.noVNC-buttons-right {
+  float:right;
+  right: 0px;
+  z-index: 2;
+  position: absolute;
+}
+
+#noVNC_status {
+  font-size: 12px;
+  padding-top: 4px;
+  height:32px;
+  text-align: center;
+  font-weight: bold;
+  color: #fff;
+}
+
+#noVNC_settings_menu {
+  margin: 3px;
+  text-align: left;
+}
+#noVNC_settings_menu ul {
+  list-style: none;
+  margin: 0px;
+  padding: 0px;
+}
+
+#noVNC_apply {
+  float:right;
+}
+
+/* Do not set width/height for VNC_screen or VNC_canvas or incorrect
+ * scaling will occur. Canvas resizes to remote VNC settings */
+#noVNC_screen {
+  display: table;
+  width:100%;
+  height:100%;
+  background-color:#313131;
+  border-bottom-right-radius: 800px 600px;
+  /*border-top-left-radius: 800px 600px;*/
+}
+
+#noVNC_container {
+  display: none;
+  position: absolute;
+  margin: 0px;
+  padding: 0px;
+  bottom: 0px;
+  top: 36px; /* the height of the control bar */
+  left: 0px;
+  right: 0px;
+  width: auto;
+  height: auto;
+}
+
+#noVNC_canvas {
+  position: absolute;
+  left: 0;
+  right: 0;
+  margin-left: auto;
+  margin-right: auto;
+}
+
+#VNC_clipboard_clear_button {
+  float:right;
+}
+#VNC_clipboard_text {
+  font-size: 11px;
+}
+
+#noVNC_clipboard_clear_button {
+  float:right;
+}
+
+/*Bubble contents divs*/
+#noVNC_settings {
+  display:none;
+  margin-top:73px;
+  right:20px;
+  position:fixed;
+}
+
+#noVNC_controls {
+  display:none;
+  margin-top:73px;
+  right:12px;
+  position:fixed;
+}
+#noVNC_controls.top:after  {
+  right:15px;
+}
+
+#noVNC_description {
+  display:none;
+  position:fixed;
+
+  margin-top:73px;
+  right:20px;
+  left:20px;
+  padding:15px;
+  color:#000;
+  background:#eee; /* default background for browsers without gradient support */
+
+  border:2px solid #E0E0E0;
+  -webkit-border-radius:10px;
+  -moz-border-radius:10px;
+  border-radius:10px;
+}
+
+#noVNC_popup_status_panel {
+  display:none;
+  position: fixed;
+  z-index: 1;
+
+  margin:15px;
+  margin-top:60px;
+  padding:15px;
+  width:auto;
+
+  text-align:center;
+  font-weight:bold;
+  word-wrap:break-word;
+  color:#fff;
+  background:rgba(0,0,0,0.65);
+
+  -webkit-border-radius:10px;
+  -moz-border-radius:10px;
+  border-radius:10px;
+}
+
+#noVNC_xvp {
+  display:none;
+  margin-top:73px;
+  right:30px;
+  position:fixed;
+}
+#noVNC_xvp.top:after {
+  right:125px;
+}
+
+#noVNC_clipboard {
+  display:none;
+  margin-top:73px;
+  right:30px;
+  position:fixed;
+}
+#noVNC_clipboard.top:after {
+  right:85px;
+}
+
+#keyboardinput {
+  width:1px;
+  height:1px;
+  background-color:#fff;
+  color:#fff;
+  border:0;
+  position: relative;
+  left: -40px;
+  z-index: -1;
+}
+
+/*
+ * Advanced Styling
+ */
+
+.noVNC_status_normal {
+  background: #b2bdcd; /* Old browsers */
+  background: -moz-linear-gradient(top, #b2bdcd 0%, #899cb3 49%, #7e93af 51%, #6e84a3 100%); /* FF3.6+ */
+  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#b2bdcd), color-stop(49%,#899cb3), color-stop(51%,#7e93af), color-stop(100%,#6e84a3)); /* Chrome,Safari4+ */
+  background: -webkit-linear-gradient(top, #b2bdcd 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* Chrome10+,Safari5.1+ */
+  background: -o-linear-gradient(top, #b2bdcd 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* Opera11.10+ */
+  background: -ms-linear-gradient(top, #b2bdcd 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* IE10+ */
+  background: linear-gradient(top, #b2bdcd 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* W3C */
+}
+.noVNC_status_error {
+  background: #f04040; /* Old browsers */
+  background: -moz-linear-gradient(top, #f04040 0%, #899cb3 49%, #7e93af 51%, #6e84a3 100%); /* FF3.6+ */
+  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#f04040), color-stop(49%,#899cb3), color-stop(51%,#7e93af), color-stop(100%,#6e84a3)); /* Chrome,Safari4+ */
+  background: -webkit-linear-gradient(top, #f04040 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* Chrome10+,Safari5.1+ */
+  background: -o-linear-gradient(top, #f04040 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* Opera11.10+ */
+  background: -ms-linear-gradient(top, #f04040 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* IE10+ */
+  background: linear-gradient(top, #f04040 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* W3C */
+}
+.noVNC_status_warn {
+  background: #f0f040; /* Old browsers */
+  background: -moz-linear-gradient(top, #f0f040 0%, #899cb3 49%, #7e93af 51%, #6e84a3 100%); /* FF3.6+ */
+  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#f0f040), color-stop(49%,#899cb3), color-stop(51%,#7e93af), color-stop(100%,#6e84a3)); /* Chrome,Safari4+ */
+  background: -webkit-linear-gradient(top, #f0f040 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* Chrome10+,Safari5.1+ */
+  background: -o-linear-gradient(top, #f0f040 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* Opera11.10+ */
+  background: -ms-linear-gradient(top, #f0f040 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* IE10+ */
+  background: linear-gradient(top, #f0f040 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* W3C */
+}
+
+/* Control bar */
+#noVNC-control-bar {
+  position:fixed;
+  
+  display:block;
+  height:36px;
+  left:0;
+  top:0;
+  width:100%;
+  z-index:200;
+}
+
+.noVNC_status_button {
+  padding: 4px 4px;
+  vertical-align: middle;
+  border:1px solid #869dbc;
+  -webkit-border-radius: 6px;
+  -moz-border-radius: 6px;
+  border-radius: 6px;
+  background: #b2bdcd; /* Old browsers */
+  background: -moz-linear-gradient(top, #b2bdcd 0%, #899cb3 49%, #7e93af 51%, #6e84a3 100%); /* FF3.6+ */
+  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#b2bdcd), color-stop(49%,#899cb3), color-stop(51%,#7e93af), color-stop(100%,#6e84a3)); /* Chrome,Safari4+ */
+  background: -webkit-linear-gradient(top, #b2bdcd 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* Chrome10+,Safari5.1+ */
+  background: -o-linear-gradient(top, #b2bdcd 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* Opera11.10+ */
+  background: -ms-linear-gradient(top, #b2bdcd 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* IE10+ */
+  filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#b2bdcd', endColorstr='#6e84a3',GradientType=0 ); /* IE6-9 */
+  background: linear-gradient(top, #b2bdcd 0%,#899cb3 49%,#7e93af 51%,#6e84a3 100%); /* W3C */
+  /*box-shadow:inset 0.4px 0.4px 0.4px #000000;*/
+}
+
+.noVNC_status_button_selected {
+  padding: 4px 4px;
+  vertical-align: middle;
+  border:1px solid #4366a9;
+  -webkit-border-radius: 6px;
+  -moz-border-radius: 6px;
+  background: #779ced; /* Old browsers */
+  background: -moz-linear-gradient(top, #779ced 0%, #3970e0 49%, #2160dd 51%, #2463df 100%); /* FF3.6+ */
+  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#779ced), color-stop(49%,#3970e0), color-stop(51%,#2160dd), color-stop(100%,#2463df)); /* Chrome,Safari4+ */
+  background: -webkit-linear-gradient(top, #779ced 0%,#3970e0 49%,#2160dd 51%,#2463df 100%); /* Chrome10+,Safari5.1+ */
+  background: -o-linear-gradient(top, #779ced 0%,#3970e0 49%,#2160dd 51%,#2463df 100%); /* Opera11.10+ */
+  background: -ms-linear-gradient(top, #779ced 0%,#3970e0 49%,#2160dd 51%,#2463df 100%); /* IE10+ */
+  filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#779ced', endColorstr='#2463df',GradientType=0 ); /* IE6-9 */
+  background: linear-gradient(top, #779ced 0%,#3970e0 49%,#2160dd 51%,#2463df 100%); /* W3C */
+ /*box-shadow:inset 0.4px 0.4px 0.4px #000000;*/
+}
+
+
+/*Settings Bubble*/
+.triangle-right {
+  position:relative;
+  padding:15px;
+  margin:1em 0 3em;
+  color:#fff;
+  background:#fff; /* default background for browsers without gradient support */
+  /* css3 */
+  /*background:-webkit-gradient(linear, 0 0, 0 100%, from(#2e88c4), to(#075698));
+  background:-moz-linear-gradient(#2e88c4, #075698);
+  background:-o-linear-gradient(#2e88c4, #075698);
+  background:linear-gradient(#2e88c4, #075698);*/
+  -webkit-border-radius:10px;
+  -moz-border-radius:10px;
+  border-radius:10px;
+  color:#000;
+  border:2px solid #E0E0E0;
+}
+
+.triangle-right.top:after {
+  border-color: transparent #E0E0E0;
+  border-width: 20px 20px 0 0;
+  bottom: auto;
+  left: auto;
+  right: 50px;
+  top: -20px;
+}
+
+.triangle-right:after {
+  content:"";
+  position:absolute;
+  bottom:-20px; /* value = - border-top-width - border-bottom-width */
+  left:50px; /* controls horizontal position */
+  border-width:20px 0 0 20px; /* vary these values to change the angle of the vertex */
+  border-style:solid;
+  border-color:#E0E0E0 transparent;
+  /* reduce the damage in FF3.0 */
+  display:block;
+  width:0;
+}
+
+.triangle-right.top:after {
+  top:-40px; /* value = - border-top-width - border-bottom-width */
+  right:50px; /* controls horizontal position */
+  bottom:auto;
+  left:auto;
+  border-width:40px 40px 0 0; /* vary these values to change the angle of the vertex */
+  border-color:transparent #E0E0E0;
+}
+
+/*Default noVNC logo.*/
+/* From: http://fonts.googleapis.com/css?family=Orbitron:700 */
+@font-face {
+  font-family: 'Orbitron';
+  font-style: normal;
+  font-weight: 700;
+  src: local('?'), url('Orbitron700.woff') format('woff'),
+                   url('Orbitron700.ttf') format('truetype');
+}
+
+#noVNC_logo {
+  margin-top: 170px;
+  margin-left: 10px;
+  color:yellow;
+  text-align:left;
+  font-family: 'Orbitron', 'OrbitronTTF', sans-serif;
+  line-height:90%;
+  text-shadow:
+       5px 5px 0 #000,
+      -1px -1px 0 #000,
+       1px -1px 0 #000,
+      -1px 1px 0 #000,
+       1px 1px 0 #000;
+}
+
+
+#noVNC_logo span{
+  color:green;
+}
+
+/* ----------------------------------------
+ * Media sizing
+ * ----------------------------------------
+ */
+
+
+.noVNC_status_button {
+  font-size: 12px;
+}
+
+#noVNC_clipboard_text {
+  width: 500px;
+}
+
+#noVNC_logo {
+  font-size: 180px;
+}
+
+.noVNC-buttons-left {
+  padding-left: 10px;
+}
+
+.noVNC-buttons-right {
+  padding-right: 10px;
+}
+
+#noVNC_status {
+  z-index: 0;
+  position: absolute;
+  width: 100%;
+  margin-left: 0px;
+}
+
+#showExtraKeysButton { display: none; }
+#toggleCtrlButton { display: inline; }
+#toggleAltButton {  display: inline; }
+#sendTabButton { display: inline; }
+#sendEscButton { display: inline; }
+
+/* left-align the status text on lower resolutions */
+@media screen and (max-width: 800px){
+  #noVNC_status {
+    z-index: 1;
+    position: relative;
+    width: auto;
+    float: left;
+    margin-left: 4px;
+  }
+}
+
+@media screen and (max-width: 800px){
+  #noVNC_clipboard_text {
+    width: 410px;
+  }
+  #noVNC_logo {
+    font-size: 150px;
+  }
+  .noVNC_status_button {
+    font-size: 10px;
+  }
+  .noVNC-buttons-left {
+    padding-left: 0px;
+  }
+  .noVNC-buttons-right {
+    padding-right: 0px;
+  }
+  /* collapse the extra keys on lower resolutions */
+  #showExtraKeysButton {
+    display: inline;
+  }
+  #toggleCtrlButton {
+    display: none;
+    position: absolute;
+    top: 30px;
+    left: 0px;
+  }
+  #toggleAltButton {
+    display: none;
+    position: absolute;
+    top: 65px;
+    left: 0px;
+  }
+  #sendTabButton {
+    display: none;
+    position: absolute;
+    top: 100px;
+    left: 0px;
+  }
+  #sendEscButton {
+    display: none;
+    position: absolute;
+    top: 135px;
+    left: 0px;
+  }
+}
+
+@media screen and (min-width: 321px) and (max-width: 600px) {
+  #noVNC_clipboard_text {
+    width: 250px;
+  }
+  #noVNC_logo {
+    font-size: 110px;
+  }
+}
+
+@media screen and (max-width: 320px) {
+  .noVNC_status_button {
+    font-size: 9px;
+  }
+  #noVNC_clipboard_text {
+    width: 220px;
+  }
+  #noVNC_logo {
+    font-size: 90px;
+  }
+}

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/base64.js

@@ -0,0 +1,113 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// From: http://hg.mozilla.org/mozilla-central/raw-file/ec10630b1a54/js/src/devtools/jint/sunspider/string-base64.js
+
+/*jslint white: false */
+/*global console */
+
+var Base64 = {
+    /* Convert data (an array of integers) to a Base64 string. */
+    toBase64Table : 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='.split(''),
+    base64Pad     : '=',
+
+    encode: function (data) {
+        "use strict";
+        var result = '';
+        var toBase64Table = Base64.toBase64Table;
+        var length = data.length;
+        var lengthpad = (length % 3);
+        // Convert every three bytes to 4 ascii characters.
+
+        for (var i = 0; i < (length - 2); i += 3) {
+            result += toBase64Table[data[i] >> 2];
+            result += toBase64Table[((data[i] & 0x03) << 4) + (data[i + 1] >> 4)];
+            result += toBase64Table[((data[i + 1] & 0x0f) << 2) + (data[i + 2] >> 6)];
+            result += toBase64Table[data[i + 2] & 0x3f];
+        }
+
+        // Convert the remaining 1 or 2 bytes, pad out to 4 characters.
+        var j = 0;
+        if (lengthpad === 2) {
+            j = length - lengthpad;
+            result += toBase64Table[data[j] >> 2];
+            result += toBase64Table[((data[j] & 0x03) << 4) + (data[j + 1] >> 4)];
+            result += toBase64Table[(data[j + 1] & 0x0f) << 2];
+            result += toBase64Table[64];
+        } else if (lengthpad === 1) {
+            j = length - lengthpad;
+            result += toBase64Table[data[j] >> 2];
+            result += toBase64Table[(data[j] & 0x03) << 4];
+            result += toBase64Table[64];
+            result += toBase64Table[64];
+        }
+
+        return result;
+    },
+
+    /* Convert Base64 data to a string */
+    /* jshint -W013 */
+    toBinaryTable : [
+        -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
+        -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
+        -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
+        52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1, 0,-1,-1,
+        -1, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
+        15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
+        -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
+        41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
+    ],
+    /* jshint +W013 */
+
+    decode: function (data, offset) {
+        "use strict";
+        offset = typeof(offset) !== 'undefined' ? offset : 0;
+        var toBinaryTable = Base64.toBinaryTable;
+        var base64Pad = Base64.base64Pad;
+        var result, result_length;
+        var leftbits = 0; // number of bits decoded, but yet to be appended
+        var leftdata = 0; // bits decoded, but yet to be appended
+        var data_length = data.indexOf('=') - offset;
+
+        if (data_length < 0) { data_length = data.length - offset; }
+
+        /* Every four characters is 3 resulting numbers */
+        result_length = (data_length >> 2) * 3 + Math.floor((data_length % 4) / 1.5);
+        result = new Array(result_length);
+
+        // Convert one by one.
+        for (var idx = 0, i = offset; i < data.length; i++) {
+            var c = toBinaryTable[data.charCodeAt(i) & 0x7f];
+            var padding = (data.charAt(i) === base64Pad);
+            // Skip illegal characters and whitespace
+            if (c === -1) {
+                console.error("Illegal character code " + data.charCodeAt(i) + " at position " + i);
+                continue;
+            }
+          
+            // Collect data into leftdata, update bitcount
+            leftdata = (leftdata << 6) | c;
+            leftbits += 6;
+
+            // If we have 8 or more bits, append 8 bits to the result
+            if (leftbits >= 8) {
+                leftbits -= 8;
+                // Append if not padding.
+                if (!padding) {
+                    result[idx++] = (leftdata >> leftbits) & 0xff;
+                }
+                leftdata &= (1 << leftbits) - 1;
+            }
+        }
+
+        // If there are any bits left, the base64 string was corrupted
+        if (leftbits) {
+            err = new Error('Corrupted base64 string');
+            err.name = 'Base64-Error';
+            throw err;
+        }
+
+        return result;
+    }
+}; /* End of Base64 namespace */

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/black.css

@@ -0,0 +1,71 @@
+/*
+ * noVNC black CSS
+ * Copyright (C) 2012 Joel Martin
+ * Copyright (C) 2013 Samuel Mannehed for Cendio AB
+ * noVNC is licensed under the MPL 2.0 (see LICENSE.txt)
+ * This file is licensed under the 2-Clause BSD license (see LICENSE.txt).
+ */
+
+#keyboardinput {
+  background-color:#000;
+}
+
+.noVNC_status_normal {
+  background: #4c4c4c; /* Old browsers */
+  background: -moz-linear-gradient(top, #4c4c4c 0%, #2c2c2c 50%, #000000 51%, #131313 100%); /* FF3.6+ */
+  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#4c4c4c), color-stop(50%,#2c2c2c), color-stop(51%,#000000), color-stop(100%,#131313)); /* Chrome,Safari4+ */
+  background: -webkit-linear-gradient(top, #4c4c4c 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* Chrome10+,Safari5.1+ */
+  background: -o-linear-gradient(top, #4c4c4c 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* Opera11.10+ */
+  background: -ms-linear-gradient(top, #4c4c4c 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* IE10+ */
+  background: linear-gradient(top, #4c4c4c 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* W3C */
+}
+.noVNC_status_error {
+  background: #f04040; /* Old browsers */
+  background: -moz-linear-gradient(top, #f04040 0%, #2c2c2c 50%, #000000 51%, #131313 100%); /* FF3.6+ */
+  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#f04040), color-stop(50%,#2c2c2c), color-stop(51%,#000000), color-stop(100%,#131313)); /* Chrome,Safari4+ */
+  background: -webkit-linear-gradient(top, #f04040 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* Chrome10+,Safari5.1+ */
+  background: -o-linear-gradient(top, #f04040 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* Opera11.10+ */
+  background: -ms-linear-gradient(top, #f04040 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* IE10+ */
+  background: linear-gradient(top, #f04040 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* W3C */
+}
+.noVNC_status_warn {
+  background: #f0f040; /* Old browsers */
+  background: -moz-linear-gradient(top, #f0f040 0%, #2c2c2c 50%, #000000 51%, #131313 100%); /* FF3.6+ */
+  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#f0f040), color-stop(50%,#2c2c2c), color-stop(51%,#000000), color-stop(100%,#131313)); /* Chrome,Safari4+ */
+  background: -webkit-linear-gradient(top, #f0f040 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* Chrome10+,Safari5.1+ */
+  background: -o-linear-gradient(top, #f0f040 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* Opera11.10+ */
+  background: -ms-linear-gradient(top, #f0f040 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* IE10+ */
+  background: linear-gradient(top, #f0f040 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* W3C */
+}
+
+.triangle-right {
+  border:2px solid #fff;
+  background:#000;
+  color:#fff;
+}
+
+.noVNC_status_button {
+  font-size: 12px;
+  vertical-align: middle;
+  border:1px solid #4c4c4c;
+
+  background: #4c4c4c; /* Old browsers */
+  background: -moz-linear-gradient(top, #4c4c4c 0%, #2c2c2c 50%, #000000 51%, #131313 100%); /* FF3.6+ */
+  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#4c4c4c), color-stop(50%,#2c2c2c), color-stop(51%,#000000), color-stop(100%,#131313)); /* Chrome,Safari4+ */
+  background: -webkit-linear-gradient(top, #4c4c4c 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* Chrome10+,Safari5.1+ */
+  background: -o-linear-gradient(top, #4c4c4c 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* Opera11.10+ */
+  background: -ms-linear-gradient(top, #4c4c4c 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* IE10+ */
+  filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#4c4c4c', endColorstr='#131313',GradientType=0 ); /* IE6-9 */
+  background: linear-gradient(top, #4c4c4c 0%,#2c2c2c 50%,#000000 51%,#131313 100%); /* W3C */
+}
+
+.noVNC_status_button_selected {
+  background: #9dd53a; /* Old browsers */
+  background: -moz-linear-gradient(top, #9dd53a 0%, #a1d54f 50%, #80c217 51%, #7cbc0a 100%); /* FF3.6+ */
+  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#9dd53a), color-stop(50%,#a1d54f), color-stop(51%,#80c217), color-stop(100%,#7cbc0a)); /* Chrome,Safari4+ */
+  background: -webkit-linear-gradient(top, #9dd53a 0%,#a1d54f 50%,#80c217 51%,#7cbc0a 100%); /* Chrome10+,Safari5.1+ */
+  background: -o-linear-gradient(top, #9dd53a 0%,#a1d54f 50%,#80c217 51%,#7cbc0a 100%); /* Opera11.10+ */
+  background: -ms-linear-gradient(top, #9dd53a 0%,#a1d54f 50%,#80c217 51%,#7cbc0a 100%); /* IE10+ */
+  filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#9dd53a', endColorstr='#7cbc0a',GradientType=0 ); /* IE6-9 */
+  background: linear-gradient(top, #9dd53a 0%,#a1d54f 50%,#80c217 51%,#7cbc0a 100%); /* W3C */
+}

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/blue.css

@@ -0,0 +1,64 @@
+/*
+ * noVNC blue CSS
+ * Copyright (C) 2012 Joel Martin
+ * Copyright (C) 2013 Samuel Mannehed for Cendio AB
+ * noVNC is licensed under the MPL 2.0 (see LICENSE.txt)
+ * This file is licensed under the 2-Clause BSD license (see LICENSE.txt).
+ */
+
+.noVNC_status_normal {
+  background-color:#04073d;
+  background-image: -webkit-gradient(
+    linear,
+    left bottom,
+    left top,
+    color-stop(0.54, rgb(10,15,79)),
+    color-stop(0.5, rgb(4,7,61))
+  );
+  background-image: -moz-linear-gradient(
+    center bottom,
+    rgb(10,15,79) 54%,
+    rgb(4,7,61) 50%
+  );
+}
+.noVNC_status_error {
+  background-color:#f04040;
+  background-image: -webkit-gradient(
+    linear,
+    left bottom,
+    left top,
+    color-stop(0.54, rgb(240,64,64)),
+    color-stop(0.5, rgb(4,7,61))
+  );
+  background-image: -moz-linear-gradient(
+    center bottom,
+    rgb(4,7,61) 54%,
+    rgb(249,64,64) 50%
+  );
+}
+.noVNC_status_warn {
+  background-color:#f0f040;
+  background-image: -webkit-gradient(
+    linear,
+    left bottom,
+    left top,
+    color-stop(0.54, rgb(240,240,64)),
+    color-stop(0.5, rgb(4,7,61))
+  );
+  background-image: -moz-linear-gradient(
+    center bottom,
+    rgb(4,7,61) 54%,
+    rgb(240,240,64) 50%
+  );
+}
+
+.triangle-right {
+  border:2px solid #fff;
+  background:#04073d;
+  color:#fff;
+}
+
+#keyboardinput {
+  background-color:#04073d;
+}
+

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/chrome-app/tcp-client.js

@@ -0,0 +1,321 @@
+/*
+Copyright 2012 Google Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+Author: Boris Smus (smus@chromium.org)
+*/
+
+(function(exports) {
+
+  // Define some local variables here.
+  var socket = chrome.socket || chrome.experimental.socket;
+  var dns = chrome.experimental.dns;
+
+  /**
+   * Creates an instance of the client
+   *
+   * @param {String} host The remote host to connect to
+   * @param {Number} port The port to connect to at the remote host
+   */
+  function TcpClient(host, port, pollInterval) {
+    this.host = host;
+    this.port = port;
+    this.pollInterval = pollInterval || 15;
+
+    // Callback functions.
+    this.callbacks = {
+      connect: null,    // Called when socket is connected.
+      disconnect: null, // Called when socket is disconnected.
+      recvBuffer: null, // Called (as ArrayBuffer) when client receives data from server.
+      recvString: null, // Called (as string) when client receives data from server.
+      sent: null        // Called when client sends data to server.
+    };
+
+    // Socket.
+    this.socketId = null;
+    this.isConnected = false;
+
+    log('initialized tcp client');
+  }
+
+  /**
+   * Connects to the TCP socket, and creates an open socket.
+   *
+   * @see http://developer.chrome.com/trunk/apps/socket.html#method-create
+   * @param {Function} callback The function to call on connection
+   */
+  TcpClient.prototype.connect = function(callback) {
+    // First resolve the hostname to an IP.
+    dns.resolve(this.host, function(result) {
+      this.addr = result.address;
+      socket.create('tcp', {}, this._onCreate.bind(this));
+
+      // Register connect callback.
+      this.callbacks.connect = callback;
+    }.bind(this));
+  };
+
+  /**
+   * Sends an arraybuffer/view down the wire to the remote side
+   *
+   * @see http://developer.chrome.com/trunk/apps/socket.html#method-write
+   * @param {String} msg The arraybuffer/view to send
+   * @param {Function} callback The function to call when the message has sent
+   */
+  TcpClient.prototype.sendBuffer = function(buf, callback) {
+    if (buf.buffer) {
+        buf = buf.buffer;
+    }
+
+    /*
+    // Debug
+    var bytes = [], u8 = new Uint8Array(buf);
+    for (var i = 0; i < u8.length; i++) {
+        bytes.push(u8[i]);
+    }
+    log("sending bytes: " + (bytes.join(',')));
+    */
+    
+    socket.write(this.socketId, buf, this._onWriteComplete.bind(this));
+
+    // Register sent callback.
+    this.callbacks.sent = callback;
+  };
+
+  /**
+   * Sends a string down the wire to the remote side
+   *
+   * @see http://developer.chrome.com/trunk/apps/socket.html#method-write
+   * @param {String} msg The string to send
+   * @param {Function} callback The function to call when the message has sent
+   */
+  TcpClient.prototype.sendString = function(msg, callback) {
+    /*
+    // Debug
+    log("sending string: " + msg);
+    */
+
+    this._stringToArrayBuffer(msg, function(arrayBuffer) {
+      socket.write(this.socketId, arrayBuffer, this._onWriteComplete.bind(this));
+    }.bind(this));
+
+    // Register sent callback.
+    this.callbacks.sent = callback;
+  };
+
+  /**
+   * Sets the callback for when a message is received
+   *
+   * @param {Function} callback The function to call when a message has arrived
+   * @param {String} type The callback argument type: "arraybuffer" or "string"
+   */
+  TcpClient.prototype.addResponseListener = function(callback, type) {
+    if (typeof type === "undefined") {
+        type = "arraybuffer";
+    }
+    // Register received callback.
+    if (type === "string") {
+      this.callbacks.recvString = callback;
+    } else {
+      this.callbacks.recvBuffer = callback;
+    }
+  };
+
+  /**
+   * Sets the callback for when the socket disconnects
+   *
+   * @param {Function} callback The function to call when the socket disconnects
+   * @param {String} type The callback argument type: "arraybuffer" or "string"
+   */
+  TcpClient.prototype.addDisconnectListener = function(callback) {
+    // Register disconnect callback.
+    this.callbacks.disconnect = callback;
+  };
+
+  /**
+   * Disconnects from the remote side
+   *
+   * @see http://developer.chrome.com/trunk/apps/socket.html#method-disconnect
+   */
+  TcpClient.prototype.disconnect = function() {
+    if (this.isConnected) {
+      this.isConnected = false;
+      socket.disconnect(this.socketId);
+      if (this.callbacks.disconnect) {
+        this.callbacks.disconnect();
+      }
+      log('socket disconnected');
+    }
+  };
+
+  /**
+   * The callback function used for when we attempt to have Chrome
+   * create a socket. If the socket is successfully created
+   * we go ahead and connect to the remote side.
+   *
+   * @private
+   * @see http://developer.chrome.com/trunk/apps/socket.html#method-connect
+   * @param {Object} createInfo The socket details
+   */
+  TcpClient.prototype._onCreate = function(createInfo) {
+    this.socketId = createInfo.socketId;
+    if (this.socketId > 0) {
+      socket.connect(this.socketId, this.addr, this.port, this._onConnectComplete.bind(this));
+    } else {
+      error('Unable to create socket');
+    }
+  };
+
+  /**
+   * The callback function used for when we attempt to have Chrome
+   * connect to the remote side. If a successful connection is
+   * made then polling starts to check for data to read
+   *
+   * @private
+   * @param {Number} resultCode Indicates whether the connection was successful
+   */
+  TcpClient.prototype._onConnectComplete = function(resultCode) {
+    // Start polling for reads.
+    this.isConnected = true;
+    setTimeout(this._periodicallyRead.bind(this), this.pollInterval);
+
+    if (this.callbacks.connect) {
+      log('connect complete');
+      this.callbacks.connect();
+    }
+    log('onConnectComplete');
+  };
+
+  /**
+   * Checks for new data to read from the socket
+   *
+   * @see http://developer.chrome.com/trunk/apps/socket.html#method-read
+   */
+  TcpClient.prototype._periodicallyRead = function() {
+    var that = this;
+    socket.getInfo(this.socketId, function (info) {
+      if (info.connected) {
+        setTimeout(that._periodicallyRead.bind(that), that.pollInterval);
+        socket.read(that.socketId, null, that._onDataRead.bind(that));
+      } else if (that.isConnected) {
+        log('socket disconnect detected');
+        that.disconnect();
+      }
+   });
+  };
+
+  /**
+   * Callback function for when data has been read from the socket.
+   * Converts the array buffer that is read in to a string
+   * and sends it on for further processing by passing it to
+   * the previously assigned callback function.
+   *
+   * @private
+   * @see TcpClient.prototype.addResponseListener
+   * @param {Object} readInfo The incoming message
+   */
+  TcpClient.prototype._onDataRead = function(readInfo) {
+    // Call received callback if there's data in the response.
+    if (readInfo.resultCode > 0) {
+      log('onDataRead');
+
+      /*
+      // Debug
+      var bytes = [], u8 = new Uint8Array(readInfo.data);
+      for (var i = 0; i < u8.length; i++) {
+          bytes.push(u8[i]);
+      }
+      log("received bytes: " + (bytes.join(',')));
+      */
+      
+      if (this.callbacks.recvBuffer) {
+        // Return raw ArrayBuffer directly.
+        this.callbacks.recvBuffer(readInfo.data);
+      }
+      if (this.callbacks.recvString) {
+        // Convert ArrayBuffer to string.
+        this._arrayBufferToString(readInfo.data, function(str) {
+          this.callbacks.recvString(str);
+        }.bind(this));
+      }
+
+      // Trigger another read right away
+      setTimeout(this._periodicallyRead.bind(this), 0);
+    }
+  };
+
+  /**
+   * Callback for when data has been successfully
+   * written to the socket.
+   *
+   * @private
+   * @param {Object} writeInfo The outgoing message
+   */
+  TcpClient.prototype._onWriteComplete = function(writeInfo) {
+    log('onWriteComplete');
+    // Call sent callback.
+    if (this.callbacks.sent) {
+      this.callbacks.sent(writeInfo);
+    }
+  };
+
+  /**
+   * Converts an array buffer to a string
+   *
+   * @private
+   * @param {ArrayBuffer} buf The buffer to convert
+   * @param {Function} callback The function to call when conversion is complete
+   */
+  TcpClient.prototype._arrayBufferToString = function(buf, callback) {
+    var bb = new Blob([new Uint8Array(buf)]);
+    var f = new FileReader();
+    f.onload = function(e) {
+      callback(e.target.result);
+    };
+    f.readAsText(bb);
+  };
+
+  /**
+   * Converts a string to an array buffer
+   *
+   * @private
+   * @param {String} str The string to convert
+   * @param {Function} callback The function to call when conversion is complete
+   */
+  TcpClient.prototype._stringToArrayBuffer = function(str, callback) {
+    var bb = new Blob([str]);
+    var f = new FileReader();
+    f.onload = function(e) {
+        callback(e.target.result);
+    };
+    f.readAsArrayBuffer(bb);
+  };
+
+  /**
+   * Wrapper function for logging
+   */
+  function log(msg) {
+    console.log(msg);
+  }
+
+  /**
+   * Wrapper function for error logging
+   */
+  function error(msg) {
+    console.error(msg);
+  }
+
+  exports.TcpClient = TcpClient;
+
+})(window);

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/des.js

@@ -0,0 +1,276 @@
+/*
+ * Ported from Flashlight VNC ActionScript implementation:
+ *     http://www.wizhelp.com/flashlight-vnc/
+ *
+ * Full attribution follows:
+ *
+ * -------------------------------------------------------------------------
+ *
+ * This DES class has been extracted from package Acme.Crypto for use in VNC.
+ * The unnecessary odd parity code has been removed.
+ *
+ * These changes are:
+ *  Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+
+ * DesCipher - the DES encryption method
+ *
+ * The meat of this code is by Dave Zimmerman <dzimm@widget.com>, and is:
+ *
+ * Copyright (c) 1996 Widget Workshop, Inc. All Rights Reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software
+ * and its documentation for NON-COMMERCIAL or COMMERCIAL purposes and
+ * without fee is hereby granted, provided that this copyright notice is kept 
+ * intact. 
+ * 
+ * WIDGET WORKSHOP MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY
+ * OF THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+ * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. WIDGET WORKSHOP SHALL NOT BE LIABLE
+ * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
+ * 
+ * THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS ON-LINE
+ * CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE
+ * PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT
+ * NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE
+ * SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE
+ * SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE
+ * PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH RISK ACTIVITIES").  WIDGET WORKSHOP
+ * SPECIFICALLY DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR
+ * HIGH RISK ACTIVITIES.
+ *
+ *
+ * The rest is:
+ *
+ * Copyright (C) 1996 by Jef Poskanzer <jef@acme.com>.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * Visit the ACME Labs Java page for up-to-date versions of this and other
+ * fine Java utilities: http://www.acme.com/java/
+ */
+
+/* jslint white: false */
+
+function DES(passwd) {
+    "use strict";
+
+    // Tables, permutations, S-boxes, etc.
+    // jshint -W013
+    var PC2 = [13,16,10,23, 0, 4, 2,27,14, 5,20, 9,22,18,11, 3,
+               25, 7,15, 6,26,19,12, 1,40,51,30,36,46,54,29,39,
+               50,44,32,47,43,48,38,55,33,52,45,41,49,35,28,31 ],
+        totrot = [ 1, 2, 4, 6, 8,10,12,14,15,17,19,21,23,25,27,28],
+        z = 0x0, a,b,c,d,e,f, SP1,SP2,SP3,SP4,SP5,SP6,SP7,SP8,
+        keys = [];
+
+    // jshint -W015
+    a=1<<16; b=1<<24; c=a|b; d=1<<2; e=1<<10; f=d|e;
+    SP1 = [c|e,z|z,a|z,c|f,c|d,a|f,z|d,a|z,z|e,c|e,c|f,z|e,b|f,c|d,b|z,z|d,
+           z|f,b|e,b|e,a|e,a|e,c|z,c|z,b|f,a|d,b|d,b|d,a|d,z|z,z|f,a|f,b|z,
+           a|z,c|f,z|d,c|z,c|e,b|z,b|z,z|e,c|d,a|z,a|e,b|d,z|e,z|d,b|f,a|f,
+           c|f,a|d,c|z,b|f,b|d,z|f,a|f,c|e,z|f,b|e,b|e,z|z,a|d,a|e,z|z,c|d];
+    a=1<<20; b=1<<31; c=a|b; d=1<<5; e=1<<15; f=d|e;
+    SP2 = [c|f,b|e,z|e,a|f,a|z,z|d,c|d,b|f,b|d,c|f,c|e,b|z,b|e,a|z,z|d,c|d,
+           a|e,a|d,b|f,z|z,b|z,z|e,a|f,c|z,a|d,b|d,z|z,a|e,z|f,c|e,c|z,z|f,
+           z|z,a|f,c|d,a|z,b|f,c|z,c|e,z|e,c|z,b|e,z|d,c|f,a|f,z|d,z|e,b|z,
+           z|f,c|e,a|z,b|d,a|d,b|f,b|d,a|d,a|e,z|z,b|e,z|f,b|z,c|d,c|f,a|e];
+    a=1<<17; b=1<<27; c=a|b; d=1<<3; e=1<<9; f=d|e;
+    SP3 = [z|f,c|e,z|z,c|d,b|e,z|z,a|f,b|e,a|d,b|d,b|d,a|z,c|f,a|d,c|z,z|f,
+           b|z,z|d,c|e,z|e,a|e,c|z,c|d,a|f,b|f,a|e,a|z,b|f,z|d,c|f,z|e,b|z,
+           c|e,b|z,a|d,z|f,a|z,c|e,b|e,z|z,z|e,a|d,c|f,b|e,b|d,z|e,z|z,c|d,
+           b|f,a|z,b|z,c|f,z|d,a|f,a|e,b|d,c|z,b|f,z|f,c|z,a|f,z|d,c|d,a|e];
+    a=1<<13; b=1<<23; c=a|b; d=1<<0; e=1<<7; f=d|e;
+    SP4 = [c|d,a|f,a|f,z|e,c|e,b|f,b|d,a|d,z|z,c|z,c|z,c|f,z|f,z|z,b|e,b|d,
+           z|d,a|z,b|z,c|d,z|e,b|z,a|d,a|e,b|f,z|d,a|e,b|e,a|z,c|e,c|f,z|f,
+           b|e,b|d,c|z,c|f,z|f,z|z,z|z,c|z,a|e,b|e,b|f,z|d,c|d,a|f,a|f,z|e,
+           c|f,z|f,z|d,a|z,b|d,a|d,c|e,b|f,a|d,a|e,b|z,c|d,z|e,b|z,a|z,c|e];
+    a=1<<25; b=1<<30; c=a|b; d=1<<8; e=1<<19; f=d|e;
+    SP5 = [z|d,a|f,a|e,c|d,z|e,z|d,b|z,a|e,b|f,z|e,a|d,b|f,c|d,c|e,z|f,b|z,
+           a|z,b|e,b|e,z|z,b|d,c|f,c|f,a|d,c|e,b|d,z|z,c|z,a|f,a|z,c|z,z|f,
+           z|e,c|d,z|d,a|z,b|z,a|e,c|d,b|f,a|d,b|z,c|e,a|f,b|f,z|d,a|z,c|e,
+           c|f,z|f,c|z,c|f,a|e,z|z,b|e,c|z,z|f,a|d,b|d,z|e,z|z,b|e,a|f,b|d];
+    a=1<<22; b=1<<29; c=a|b; d=1<<4; e=1<<14; f=d|e;
+    SP6 = [b|d,c|z,z|e,c|f,c|z,z|d,c|f,a|z,b|e,a|f,a|z,b|d,a|d,b|e,b|z,z|f,
+           z|z,a|d,b|f,z|e,a|e,b|f,z|d,c|d,c|d,z|z,a|f,c|e,z|f,a|e,c|e,b|z,
+           b|e,z|d,c|d,a|e,c|f,a|z,z|f,b|d,a|z,b|e,b|z,z|f,b|d,c|f,a|e,c|z,
+           a|f,c|e,z|z,c|d,z|d,z|e,c|z,a|f,z|e,a|d,b|f,z|z,c|e,b|z,a|d,b|f];
+    a=1<<21; b=1<<26; c=a|b; d=1<<1; e=1<<11; f=d|e;
+    SP7 = [a|z,c|d,b|f,z|z,z|e,b|f,a|f,c|e,c|f,a|z,z|z,b|d,z|d,b|z,c|d,z|f,
+           b|e,a|f,a|d,b|e,b|d,c|z,c|e,a|d,c|z,z|e,z|f,c|f,a|e,z|d,b|z,a|e,
+           b|z,a|e,a|z,b|f,b|f,c|d,c|d,z|d,a|d,b|z,b|e,a|z,c|e,z|f,a|f,c|e,
+           z|f,b|d,c|f,c|z,a|e,z|z,z|d,c|f,z|z,a|f,c|z,z|e,b|d,b|e,z|e,a|d];
+    a=1<<18; b=1<<28; c=a|b; d=1<<6; e=1<<12; f=d|e;
+    SP8 = [b|f,z|e,a|z,c|f,b|z,b|f,z|d,b|z,a|d,c|z,c|f,a|e,c|e,a|f,z|e,z|d,
+           c|z,b|d,b|e,z|f,a|e,a|d,c|d,c|e,z|f,z|z,z|z,c|d,b|d,b|e,a|f,a|z,
+           a|f,a|z,c|e,z|e,z|d,c|d,z|e,a|f,b|e,z|d,b|d,c|z,c|d,b|z,a|z,b|f,
+           z|z,c|f,a|d,b|d,c|z,b|e,b|f,z|z,c|f,a|e,a|e,z|f,z|f,a|d,b|z,c|e];
+    // jshint +W013,+W015
+
+    // Set the key.
+    function setKeys(keyBlock) {
+        var i, j, l, m, n, o, pc1m = [], pcr = [], kn = [],
+            raw0, raw1, rawi, KnLi;
+
+        for (j = 0, l = 56; j < 56; ++j, l -= 8) {
+            l += l < -5 ? 65 : l < -3 ? 31 : l < -1 ? 63 : l === 27 ? 35 : 0; // PC1
+            m = l & 0x7;
+            pc1m[j] = ((keyBlock[l >>> 3] & (1<<m)) !== 0) ? 1: 0;
+        }
+
+        for (i = 0; i < 16; ++i) {
+            m = i << 1;
+            n = m + 1;
+            kn[m] = kn[n] = 0;
+            for (o = 28; o < 59; o += 28) {
+                for (j = o - 28; j < o; ++j) {
+                    l = j + totrot[i];
+                    if (l < o) {
+                        pcr[j] = pc1m[l];
+                    } else {
+                        pcr[j] = pc1m[l - 28];
+                    }
+                }
+            }
+            for (j = 0; j < 24; ++j) {
+                if (pcr[PC2[j]] !== 0) {
+                    kn[m] |= 1 << (23 - j);
+                }
+                if (pcr[PC2[j + 24]] !== 0) {
+                    kn[n] |= 1 << (23 - j);
+                }
+            }
+        }
+
+        // cookey
+        for (i = 0, rawi = 0, KnLi = 0; i < 16; ++i) {
+            raw0 = kn[rawi++];
+            raw1 = kn[rawi++];
+            keys[KnLi] = (raw0 & 0x00fc0000) << 6;
+            keys[KnLi] |= (raw0 & 0x00000fc0) << 10;
+            keys[KnLi] |= (raw1 & 0x00fc0000) >>> 10;
+            keys[KnLi] |= (raw1 & 0x00000fc0) >>> 6;
+            ++KnLi;
+            keys[KnLi] = (raw0 & 0x0003f000) << 12;
+            keys[KnLi] |= (raw0 & 0x0000003f) << 16;
+            keys[KnLi] |= (raw1 & 0x0003f000) >>> 4;
+            keys[KnLi] |= (raw1 & 0x0000003f);
+            ++KnLi;
+        }
+    }
+
+    // Encrypt 8 bytes of text
+    function enc8(text) {
+        var i = 0, b = text.slice(), fval, keysi = 0,
+            l, r, x; // left, right, accumulator
+
+        // Squash 8 bytes to 2 ints
+        l = b[i++]<<24 | b[i++]<<16 | b[i++]<<8 | b[i++];
+        r = b[i++]<<24 | b[i++]<<16 | b[i++]<<8 | b[i++];
+
+        x = ((l >>> 4) ^ r) & 0x0f0f0f0f;
+        r ^= x;
+        l ^= (x << 4);
+        x = ((l >>> 16) ^ r) & 0x0000ffff;
+        r ^= x;
+        l ^= (x << 16);
+        x = ((r >>> 2) ^ l) & 0x33333333;
+        l ^= x;
+        r ^= (x << 2);
+        x = ((r >>> 8) ^ l) & 0x00ff00ff;
+        l ^= x;
+        r ^= (x << 8);
+        r = (r << 1) | ((r >>> 31) & 1);
+        x = (l ^ r) & 0xaaaaaaaa;
+        l ^= x;
+        r ^= x;
+        l = (l << 1) | ((l >>> 31) & 1);
+
+        for (i = 0; i < 8; ++i) {
+            x = (r << 28) | (r >>> 4);
+            x ^= keys[keysi++];
+            fval =  SP7[x & 0x3f];
+            fval |= SP5[(x >>> 8) & 0x3f];
+            fval |= SP3[(x >>> 16) & 0x3f];
+            fval |= SP1[(x >>> 24) & 0x3f];
+            x = r ^ keys[keysi++];
+            fval |= SP8[x & 0x3f];
+            fval |= SP6[(x >>> 8) & 0x3f];
+            fval |= SP4[(x >>> 16) & 0x3f];
+            fval |= SP2[(x >>> 24) & 0x3f];
+            l ^= fval;
+            x = (l << 28) | (l >>> 4);
+            x ^= keys[keysi++];
+            fval =  SP7[x & 0x3f];
+            fval |= SP5[(x >>> 8) & 0x3f];
+            fval |= SP3[(x >>> 16) & 0x3f];
+            fval |= SP1[(x >>> 24) & 0x3f];
+            x = l ^ keys[keysi++];
+            fval |= SP8[x & 0x0000003f];
+            fval |= SP6[(x >>> 8) & 0x3f];
+            fval |= SP4[(x >>> 16) & 0x3f];
+            fval |= SP2[(x >>> 24) & 0x3f];
+            r ^= fval;
+        }
+
+        r = (r << 31) | (r >>> 1);
+        x = (l ^ r) & 0xaaaaaaaa;
+        l ^= x;
+        r ^= x;
+        l = (l << 31) | (l >>> 1);
+        x = ((l >>> 8) ^ r) & 0x00ff00ff;
+        r ^= x;
+        l ^= (x << 8);
+        x = ((l >>> 2) ^ r) & 0x33333333;
+        r ^= x;
+        l ^= (x << 2);
+        x = ((r >>> 16) ^ l) & 0x0000ffff;
+        l ^= x;
+        r ^= (x << 16);
+        x = ((r >>> 4) ^ l) & 0x0f0f0f0f;
+        l ^= x;
+        r ^= (x << 4);
+
+        // Spread ints to bytes
+        x = [r, l];
+        for (i = 0; i < 8; i++) {
+            b[i] = (x[i>>>2] >>> (8 * (3 - (i % 4)))) % 256;
+            if (b[i] < 0) { b[i] += 256; } // unsigned
+        }
+        return b;
+    }
+
+    // Encrypt 16 bytes of text using passwd as key
+    function encrypt(t) {
+        return enc8(t.slice(0, 8)).concat(enc8(t.slice(8, 16)));
+    }
+
+    setKeys(passwd);             // Setup keys
+    return {'encrypt': encrypt}; // Public interface
+
+} // function DES

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/display.js

@@ -0,0 +1,793 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2012 Joel Martin
+ * Copyright (C) 2015 Samuel Mannehed for Cendio AB
+ * Licensed under MPL 2.0 (see LICENSE.txt)
+ *
+ * See README.md for usage and integration instructions.
+ */
+
+/*jslint browser: true, white: false */
+/*global Util, Base64, changeCursor */
+
+var Display;
+
+(function () {
+    "use strict";
+
+    Display = function (defaults) {
+        this._drawCtx = null;
+        this._c_forceCanvas = false;
+
+        this._renderQ = [];  // queue drawing actions for in-oder rendering
+
+        // the full frame buffer (logical canvas) size
+        this._fb_width = 0;
+        this._fb_height = 0;
+
+        // the size limit of the viewport (start disabled)
+        this._maxWidth = 0;
+        this._maxHeight = 0;
+
+        // the visible "physical canvas" viewport
+        this._viewportLoc = { 'x': 0, 'y': 0, 'w': 0, 'h': 0 };
+        this._cleanRect = { 'x1': 0, 'y1': 0, 'x2': -1, 'y2': -1 };
+
+        this._prevDrawStyle = "";
+        this._tile = null;
+        this._tile16x16 = null;
+        this._tile_x = 0;
+        this._tile_y = 0;
+
+        Util.set_defaults(this, defaults, {
+            'true_color': true,
+            'colourMap': [],
+            'scale': 1.0,
+            'viewport': false,
+            'render_mode': ''
+        });
+
+        Util.Debug(">> Display.constructor");
+
+        if (!this._target) {
+            throw new Error("Target must be set");
+        }
+
+        if (typeof this._target === 'string') {
+            throw new Error('target must be a DOM element');
+        }
+
+        if (!this._target.getContext) {
+            throw new Error("no getContext method");
+        }
+
+        if (!this._drawCtx) {
+            this._drawCtx = this._target.getContext('2d');
+        }
+
+        Util.Debug("User Agent: " + navigator.userAgent);
+        if (Util.Engine.gecko) { Util.Debug("Browser: gecko " + Util.Engine.gecko); }
+        if (Util.Engine.webkit) { Util.Debug("Browser: webkit " + Util.Engine.webkit); }
+        if (Util.Engine.trident) { Util.Debug("Browser: trident " + Util.Engine.trident); }
+        if (Util.Engine.presto) { Util.Debug("Browser: presto " + Util.Engine.presto); }
+
+        this.clear();
+
+        // Check canvas features
+        if ('createImageData' in this._drawCtx) {
+            this._render_mode = 'canvas rendering';
+        } else {
+            throw new Error("Canvas does not support createImageData");
+        }
+
+        if (this._prefer_js === null) {
+            Util.Info("Prefering javascript operations");
+            this._prefer_js = true;
+        }
+
+        // Determine browser support for setting the cursor via data URI scheme
+        if (this._cursor_uri || this._cursor_uri === null ||
+                this._cursor_uri === undefined) {
+            this._cursor_uri = Util.browserSupportsCursorURIs(this._target);
+        }
+
+        Util.Debug("<< Display.constructor");
+    };
+
+    Display.prototype = {
+        // Public methods
+        viewportChangePos: function (deltaX, deltaY) {
+            var vp = this._viewportLoc;
+
+            if (!this._viewport) {
+                deltaX = -vp.w;  // clamped later of out of bounds
+                deltaY = -vp.h;
+            }
+
+            var vx2 = vp.x + vp.w - 1;
+            var vy2 = vp.y + vp.h - 1;
+
+            // Position change
+
+            if (deltaX < 0 && vp.x + deltaX < 0) {
+                deltaX = -vp.x;
+            }
+            if (vx2 + deltaX >= this._fb_width) {
+                deltaX -= vx2 + deltaX - this._fb_width + 1;
+            }
+
+            if (vp.y + deltaY < 0) {
+                deltaY = -vp.y;
+            }
+            if (vy2 + deltaY >= this._fb_height) {
+                deltaY -= (vy2 + deltaY - this._fb_height + 1);
+            }
+
+            if (deltaX === 0 && deltaY === 0) {
+                return;
+            }
+            Util.Debug("viewportChange deltaX: " + deltaX + ", deltaY: " + deltaY);
+
+            vp.x += deltaX;
+            vx2 += deltaX;
+            vp.y += deltaY;
+            vy2 += deltaY;
+
+            // Update the clean rectangle
+            var cr = this._cleanRect;
+            if (vp.x > cr.x1) {
+                cr.x1 = vp.x;
+            }
+            if (vx2 < cr.x2) {
+                cr.x2 = vx2;
+            }
+            if (vp.y > cr.y1) {
+                cr.y1 = vp.y;
+            }
+            if (vy2 < cr.y2) {
+                cr.y2 = vy2;
+            }
+
+            var x1, w;
+            if (deltaX < 0) {
+                // Shift viewport left, redraw left section
+                x1 = 0;
+                w = -deltaX;
+            } else {
+                // Shift viewport right, redraw right section
+                x1 = vp.w - deltaX;
+                w = deltaX;
+            }
+
+            var y1, h;
+            if (deltaY < 0) {
+                // Shift viewport up, redraw top section
+                y1 = 0;
+                h = -deltaY;
+            } else {
+                // Shift viewport down, redraw bottom section
+                y1 = vp.h - deltaY;
+                h = deltaY;
+            }
+
+            // Copy the valid part of the viewport to the shifted location
+            var saveStyle = this._drawCtx.fillStyle;
+            var canvas = this._target;
+            this._drawCtx.fillStyle = "rgb(255,255,255)";
+            if (deltaX !== 0) {
+                this._drawCtx.drawImage(canvas, 0, 0, vp.w, vp.h, -deltaX, 0, vp.w, vp.h);
+                this._drawCtx.fillRect(x1, 0, w, vp.h);
+            }
+            if (deltaY !== 0) {
+                this._drawCtx.drawImage(canvas, 0, 0, vp.w, vp.h, 0, -deltaY, vp.w, vp.h);
+                this._drawCtx.fillRect(0, y1, vp.w, h);
+            }
+            this._drawCtx.fillStyle = saveStyle;
+        },
+
+        viewportChangeSize: function(width, height) {
+
+            if (typeof(width) === "undefined" || typeof(height) === "undefined") {
+
+                Util.Debug("Setting viewport to full display region");
+                width = this._fb_width;
+                height = this._fb_height;
+            }
+
+            var vp = this._viewportLoc;
+            if (vp.w !== width || vp.h !== height) {
+
+                if (this._viewport) {
+                    if (this._maxWidth !== 0 && width > this._maxWidth) {
+                        width = this._maxWidth;
+                    }
+                    if (this._maxHeight !== 0 && height > this._maxHeight) {
+                        height = this._maxHeight;
+                    }
+                }
+
+                var cr = this._cleanRect;
+
+                if (width < vp.w &&  cr.x2 > vp.x + width - 1) {
+                    cr.x2 = vp.x + width - 1;
+                }
+                if (height < vp.h &&  cr.y2 > vp.y + height - 1) {
+                    cr.y2 = vp.y + height - 1;
+                }
+
+                vp.w = width;
+                vp.h = height;
+
+                var canvas = this._target;
+                if (canvas.width !== width || canvas.height !== height) {
+
+                    // We have to save the canvas data since changing the size will clear it
+                    var saveImg = null;
+                    if (vp.w > 0 && vp.h > 0 && canvas.width > 0 && canvas.height > 0) {
+                        var img_width = canvas.width < vp.w ? canvas.width : vp.w;
+                        var img_height = canvas.height < vp.h ? canvas.height : vp.h;
+                        saveImg = this._drawCtx.getImageData(0, 0, img_width, img_height);
+                    }
+
+                    if (canvas.width  !== width)  { canvas.width  = width; }
+                    if (canvas.height !== height) { canvas.height = height; }
+
+                    if (this._viewport) {
+                        canvas.style.height = height + 'px';
+                        canvas.style.width = width + 'px';
+                    }
+
+                    if (saveImg) {
+                        this._drawCtx.putImageData(saveImg, 0, 0);
+                    }
+                }
+            }
+        },
+
+        // Return a map of clean and dirty areas of the viewport and reset the
+        // tracking of clean and dirty areas
+        //
+        // Returns: { 'cleanBox': { 'x': x, 'y': y, 'w': w, 'h': h},
+        //            'dirtyBoxes': [{ 'x': x, 'y': y, 'w': w, 'h': h }, ...] }
+        getCleanDirtyReset: function () {
+            var vp = this._viewportLoc;
+            var cr = this._cleanRect;
+
+            var cleanBox = { 'x': cr.x1, 'y': cr.y1,
+                             'w': cr.x2 - cr.x1 + 1, 'h': cr.y2 - cr.y1 + 1 };
+
+            var dirtyBoxes = [];
+            if (cr.x1 >= cr.x2 || cr.y1 >= cr.y2) {
+                // Whole viewport is dirty
+                dirtyBoxes.push({ 'x': vp.x, 'y': vp.y, 'w': vp.w, 'h': vp.h });
+            } else {
+                // Redraw dirty regions
+                var vx2 = vp.x + vp.w - 1;
+                var vy2 = vp.y + vp.h - 1;
+
+                if (vp.x < cr.x1) {
+                    // left side dirty region
+                    dirtyBoxes.push({'x': vp.x, 'y': vp.y,
+                                     'w': cr.x1 - vp.x + 1, 'h': vp.h});
+                }
+                if (vx2 > cr.x2) {
+                    // right side dirty region
+                    dirtyBoxes.push({'x': cr.x2 + 1, 'y': vp.y,
+                                     'w': vx2 - cr.x2, 'h': vp.h});
+                }
+                if(vp.y < cr.y1) {
+                    // top/middle dirty region
+                    dirtyBoxes.push({'x': cr.x1, 'y': vp.y,
+                                     'w': cr.x2 - cr.x1 + 1, 'h': cr.y1 - vp.y});
+                }
+                if (vy2 > cr.y2) {
+                    // bottom/middle dirty region
+                    dirtyBoxes.push({'x': cr.x1, 'y': cr.y2 + 1,
+                                     'w': cr.x2 - cr.x1 + 1, 'h': vy2 - cr.y2});
+                }
+            }
+
+            this._cleanRect = {'x1': vp.x, 'y1': vp.y,
+                               'x2': vp.x + vp.w - 1, 'y2': vp.y + vp.h - 1};
+
+            return {'cleanBox': cleanBox, 'dirtyBoxes': dirtyBoxes};
+        },
+
+        absX: function (x) {
+            return x + this._viewportLoc.x;
+        },
+
+        absY: function (y) {
+            return y + this._viewportLoc.y;
+        },
+
+        resize: function (width, height) {
+            this._prevDrawStyle = "";
+
+            this._fb_width = width;
+            this._fb_height = height;
+
+            this._rescale(this._scale);
+
+            this.viewportChangeSize();
+        },
+
+        clear: function () {
+            if (this._logo) {
+                this.resize(this._logo.width, this._logo.height);
+                this.blitStringImage(this._logo.data, 0, 0);
+            } else {
+                if (Util.Engine.trident === 6) {
+                    // NB(directxman12): there's a bug in IE10 where we can fail to actually
+                    //                   clear the canvas here because of the resize.
+                    //                   Clearing the current viewport first fixes the issue
+                    this._drawCtx.clearRect(0, 0, this._viewportLoc.w, this._viewportLoc.h);
+                }
+                this.resize(240, 20);
+                this._drawCtx.clearRect(0, 0, this._viewportLoc.w, this._viewportLoc.h);
+            }
+
+            this._renderQ = [];
+        },
+
+        fillRect: function (x, y, width, height, color) {
+            this._setFillColor(color);
+            this._drawCtx.fillRect(x - this._viewportLoc.x, y - this._viewportLoc.y, width, height);
+        },
+
+        copyImage: function (old_x, old_y, new_x, new_y, w, h) {
+            var x1 = old_x - this._viewportLoc.x;
+            var y1 = old_y - this._viewportLoc.y;
+            var x2 = new_x - this._viewportLoc.x;
+            var y2 = new_y - this._viewportLoc.y;
+
+            this._drawCtx.drawImage(this._target, x1, y1, w, h, x2, y2, w, h);
+        },
+
+        // start updating a tile
+        startTile: function (x, y, width, height, color) {
+            this._tile_x = x;
+            this._tile_y = y;
+            if (width === 16 && height === 16) {
+                this._tile = this._tile16x16;
+            } else {
+                this._tile = this._drawCtx.createImageData(width, height);
+            }
+
+            if (this._prefer_js) {
+                var bgr;
+                if (this._true_color) {
+                    bgr = color;
+                } else {
+                    bgr = this._colourMap[color[0]];
+                }
+                var red = bgr[2];
+                var green = bgr[1];
+                var blue = bgr[0];
+
+                var data = this._tile.data;
+                for (var i = 0; i < width * height * 4; i += 4) {
+                    data[i] = red;
+                    data[i + 1] = green;
+                    data[i + 2] = blue;
+                    data[i + 3] = 255;
+                }
+            } else {
+                this.fillRect(x, y, width, height, color);
+            }
+        },
+
+        // update sub-rectangle of the current tile
+        subTile: function (x, y, w, h, color) {
+            if (this._prefer_js) {
+                var bgr;
+                if (this._true_color) {
+                    bgr = color;
+                } else {
+                    bgr = this._colourMap[color[0]];
+                }
+                var red = bgr[2];
+                var green = bgr[1];
+                var blue = bgr[0];
+                var xend = x + w;
+                var yend = y + h;
+
+                var data = this._tile.data;
+                var width = this._tile.width;
+                for (var j = y; j < yend; j++) {
+                    for (var i = x; i < xend; i++) {
+                        var p = (i + (j * width)) * 4;
+                        data[p] = red;
+                        data[p + 1] = green;
+                        data[p + 2] = blue;
+                        data[p + 3] = 255;
+                    }
+                }
+            } else {
+                this.fillRect(this._tile_x + x, this._tile_y + y, w, h, color);
+            }
+        },
+
+        // draw the current tile to the screen
+        finishTile: function () {
+            if (this._prefer_js) {
+                this._drawCtx.putImageData(this._tile, this._tile_x - this._viewportLoc.x,
+                                           this._tile_y - this._viewportLoc.y);
+            }
+            // else: No-op -- already done by setSubTile
+        },
+
+        blitImage: function (x, y, width, height, arr, offset) {
+            if (this._true_color) {
+                this._bgrxImageData(x, y, this._viewportLoc.x, this._viewportLoc.y, width, height, arr, offset);
+            } else {
+                this._cmapImageData(x, y, this._viewportLoc.x, this._viewportLoc.y, width, height, arr, offset);
+            }
+        },
+
+        blitRgbImage: function (x, y , width, height, arr, offset) {
+            if (this._true_color) {
+                this._rgbImageData(x, y, this._viewportLoc.x, this._viewportLoc.y, width, height, arr, offset);
+            } else {
+                // probably wrong?
+                this._cmapImageData(x, y, this._viewportLoc.x, this._viewportLoc.y, width, height, arr, offset);
+            }
+        },
+
+        blitStringImage: function (str, x, y) {
+            var img = new Image();
+            img.onload = function () {
+                this._drawCtx.drawImage(img, x - this._viewportLoc.x, y - this._viewportLoc.y);
+            }.bind(this);
+            img.src = str;
+            return img; // for debugging purposes
+        },
+
+        // wrap ctx.drawImage but relative to viewport
+        drawImage: function (img, x, y) {
+            this._drawCtx.drawImage(img, x - this._viewportLoc.x, y - this._viewportLoc.y);
+        },
+
+        renderQ_push: function (action) {
+            this._renderQ.push(action);
+            if (this._renderQ.length === 1) {
+                // If this can be rendered immediately it will be, otherwise
+                // the scanner will start polling the queue (every
+                // requestAnimationFrame interval)
+                this._scan_renderQ();
+            }
+        },
+
+        changeCursor: function (pixels, mask, hotx, hoty, w, h) {
+            if (this._cursor_uri === false) {
+                Util.Warn("changeCursor called but no cursor data URI support");
+                return;
+            }
+
+            if (this._true_color) {
+                Display.changeCursor(this._target, pixels, mask, hotx, hoty, w, h);
+            } else {
+                Display.changeCursor(this._target, pixels, mask, hotx, hoty, w, h, this._colourMap);
+            }
+        },
+
+        defaultCursor: function () {
+            this._target.style.cursor = "default";
+        },
+
+        disableLocalCursor: function () {
+            this._target.style.cursor = "none";
+        },
+
+        clippingDisplay: function () {
+            var vp = this._viewportLoc;
+
+            var fbClip = this._fb_width > vp.w || this._fb_height > vp.h;
+            var limitedVp = this._maxWidth !== 0 && this._maxHeight !== 0;
+            var clipping = false;
+
+            if (limitedVp) {
+                clipping = vp.w > this._maxWidth || vp.h > this._maxHeight;
+            }
+
+            return fbClip || (limitedVp && clipping);
+        },
+
+        // Overridden getters/setters
+        get_context: function () {
+            return this._drawCtx;
+        },
+
+        set_scale: function (scale) {
+            this._rescale(scale);
+        },
+
+        set_width: function (w) {
+            this._fb_width = w;
+        },
+        get_width: function () {
+            return this._fb_width;
+        },
+
+        set_height: function (h) {
+            this._fb_height =  h;
+        },
+        get_height: function () {
+            return this._fb_height;
+        },
+
+        autoscale: function (containerWidth, containerHeight, downscaleOnly) {
+            var targetAspectRatio = containerWidth / containerHeight;
+            var fbAspectRatio = this._fb_width / this._fb_height;
+
+            var scaleRatio;
+            if (fbAspectRatio >= targetAspectRatio) {
+                scaleRatio = containerWidth / this._fb_width;
+            } else {
+                scaleRatio = containerHeight / this._fb_height;
+            }
+
+            var targetW, targetH;
+            if (scaleRatio > 1.0 && downscaleOnly) {
+                targetW = this._fb_width;
+                targetH = this._fb_height;
+                scaleRatio = 1.0;
+            } else if (fbAspectRatio >= targetAspectRatio) {
+                targetW = containerWidth;
+                targetH = Math.round(containerWidth / fbAspectRatio);
+            } else {
+                targetW = Math.round(containerHeight * fbAspectRatio);
+                targetH = containerHeight;
+            }
+
+            // NB(directxman12): If you set the width directly, or set the
+            //                   style width to a number, the canvas is cleared.
+            //                   However, if you set the style width to a string
+            //                   ('NNNpx'), the canvas is scaled without clearing.
+            this._target.style.width = targetW + 'px';
+            this._target.style.height = targetH + 'px';
+
+            this._scale = scaleRatio;
+
+            return scaleRatio;  // so that the mouse, etc scale can be set
+        },
+
+        // Private Methods
+        _rescale: function (factor) {
+            this._scale = factor;
+
+            var w;
+            var h;
+
+            if (this._viewport &&
+                this._maxWidth !== 0 && this._maxHeight !== 0) {
+                w = Math.min(this._fb_width, this._maxWidth);
+                h = Math.min(this._fb_height, this._maxHeight);
+            } else {
+                w = this._fb_width;
+                h = this._fb_height;
+            }
+
+            this._target.style.width = Math.round(factor * w) + 'px';
+            this._target.style.height = Math.round(factor * h) + 'px';
+        },
+
+        _setFillColor: function (color) {
+            var bgr;
+            if (this._true_color) {
+                bgr = color;
+            } else {
+                bgr = this._colourMap[color[0]];
+            }
+
+            var newStyle = 'rgb(' + bgr[2] + ',' + bgr[1] + ',' + bgr[0] + ')';
+            if (newStyle !== this._prevDrawStyle) {
+                this._drawCtx.fillStyle = newStyle;
+                this._prevDrawStyle = newStyle;
+            }
+        },
+
+        _rgbImageData: function (x, y, vx, vy, width, height, arr, offset) {
+            var img = this._drawCtx.createImageData(width, height);
+            var data = img.data;
+            for (var i = 0, j = offset; i < width * height * 4; i += 4, j += 3) {
+                data[i]     = arr[j];
+                data[i + 1] = arr[j + 1];
+                data[i + 2] = arr[j + 2];
+                data[i + 3] = 255;  // Alpha
+            }
+            this._drawCtx.putImageData(img, x - vx, y - vy);
+        },
+
+        _bgrxImageData: function (x, y, vx, vy, width, height, arr, offset) {
+            var img = this._drawCtx.createImageData(width, height);
+            var data = img.data;
+            for (var i = 0, j = offset; i < width * height * 4; i += 4, j += 4) {
+                data[i]     = arr[j + 2];
+                data[i + 1] = arr[j + 1];
+                data[i + 2] = arr[j];
+                data[i + 3] = 255;  // Alpha
+            }
+            this._drawCtx.putImageData(img, x - vx, y - vy);
+        },
+
+        _cmapImageData: function (x, y, vx, vy, width, height, arr, offset) {
+            var img = this._drawCtx.createImageData(width, height);
+            var data = img.data;
+            var cmap = this._colourMap;
+            for (var i = 0, j = offset; i < width * height * 4; i += 4, j++) {
+                var bgr = cmap[arr[j]];
+                data[i]     = bgr[2];
+                data[i + 1] = bgr[1];
+                data[i + 2] = bgr[0];
+                data[i + 3] = 255;  // Alpha
+            }
+            this._drawCtx.putImageData(img, x - vx, y - vy);
+        },
+
+        _scan_renderQ: function () {
+            var ready = true;
+            while (ready && this._renderQ.length > 0) {
+                var a = this._renderQ[0];
+                switch (a.type) {
+                    case 'copy':
+                        this.copyImage(a.old_x, a.old_y, a.x, a.y, a.width, a.height);
+                        break;
+                    case 'fill':
+                        this.fillRect(a.x, a.y, a.width, a.height, a.color);
+                        break;
+                    case 'blit':
+                        this.blitImage(a.x, a.y, a.width, a.height, a.data, 0);
+                        break;
+                    case 'blitRgb':
+                        this.blitRgbImage(a.x, a.y, a.width, a.height, a.data, 0);
+                        break;
+                    case 'img':
+                        if (a.img.complete) {
+                            this.drawImage(a.img, a.x, a.y);
+                        } else {
+                            // We need to wait for this image to 'load'
+                            // to keep things in-order
+                            ready = false;
+                        }
+                        break;
+                }
+
+                if (ready) {
+                    this._renderQ.shift();
+                }
+            }
+
+            if (this._renderQ.length > 0) {
+                requestAnimFrame(this._scan_renderQ.bind(this));
+            }
+        },
+    };
+
+    Util.make_properties(Display, [
+        ['target', 'wo', 'dom'],       // Canvas element for rendering
+        ['context', 'ro', 'raw'],      // Canvas 2D context for rendering (read-only)
+        ['logo', 'rw', 'raw'],         // Logo to display when cleared: {"width": w, "height": h, "data": data}
+        ['true_color', 'rw', 'bool'],  // Use true-color pixel data
+        ['colourMap', 'rw', 'arr'],    // Colour map array (when not true-color)
+        ['scale', 'rw', 'float'],      // Display area scale factor 0.0 - 1.0
+        ['viewport', 'rw', 'bool'],    // Use viewport clipping
+        ['width', 'rw', 'int'],        // Display area width
+        ['height', 'rw', 'int'],       // Display area height
+        ['maxWidth', 'rw', 'int'],     // Viewport max width (0 if disabled)
+        ['maxHeight', 'rw', 'int'],    // Viewport max height (0 if disabled)
+
+        ['render_mode', 'ro', 'str'],  // Canvas rendering mode (read-only)
+
+        ['prefer_js', 'rw', 'str'],    // Prefer Javascript over canvas methods
+        ['cursor_uri', 'rw', 'raw']    // Can we render cursor using data URI
+    ]);
+
+    // Class Methods
+    Display.changeCursor = function (target, pixels, mask, hotx, hoty, w0, h0, cmap) {
+        var w = w0;
+        var h = h0;
+        if (h < w) {
+            h = w;  // increase h to make it square
+        } else {
+            w = h;  // increase w to make it square
+        }
+
+        var cur = [];
+
+        // Push multi-byte little-endian values
+        cur.push16le = function (num) {
+            this.push(num & 0xFF, (num >> 8) & 0xFF);
+        };
+        cur.push32le = function (num) {
+            this.push(num & 0xFF,
+                      (num >> 8) & 0xFF,
+                      (num >> 16) & 0xFF,
+                      (num >> 24) & 0xFF);
+        };
+
+        var IHDRsz = 40;
+        var RGBsz = w * h * 4;
+        var XORsz = Math.ceil((w * h) / 8.0);
+        var ANDsz = Math.ceil((w * h) / 8.0);
+
+        cur.push16le(0);        // 0: Reserved
+        cur.push16le(2);        // 2: .CUR type
+        cur.push16le(1);        // 4: Number of images, 1 for non-animated ico
+
+        // Cursor #1 header (ICONDIRENTRY)
+        cur.push(w);            // 6: width
+        cur.push(h);            // 7: height
+        cur.push(0);            // 8: colors, 0 -> true-color
+        cur.push(0);            // 9: reserved
+        cur.push16le(hotx);     // 10: hotspot x coordinate
+        cur.push16le(hoty);     // 12: hotspot y coordinate
+        cur.push32le(IHDRsz + RGBsz + XORsz + ANDsz);
+                                // 14: cursor data byte size
+        cur.push32le(22);       // 18: offset of cursor data in the file
+
+        // Cursor #1 InfoHeader (ICONIMAGE/BITMAPINFO)
+        cur.push32le(IHDRsz);   // 22: InfoHeader size
+        cur.push32le(w);        // 26: Cursor width
+        cur.push32le(h * 2);    // 30: XOR+AND height
+        cur.push16le(1);        // 34: number of planes
+        cur.push16le(32);       // 36: bits per pixel
+        cur.push32le(0);        // 38: Type of compression
+
+        cur.push32le(XORsz + ANDsz);
+                                // 42: Size of Image
+        cur.push32le(0);        // 46: reserved
+        cur.push32le(0);        // 50: reserved
+        cur.push32le(0);        // 54: reserved
+        cur.push32le(0);        // 58: reserved
+
+        // 62: color data (RGBQUAD icColors[])
+        var y, x;
+        for (y = h - 1; y >= 0; y--) {
+            for (x = 0; x < w; x++) {
+                if (x >= w0 || y >= h0) {
+                    cur.push(0);  // blue
+                    cur.push(0);  // green
+                    cur.push(0);  // red
+                    cur.push(0);  // alpha
+                } else {
+                    var idx = y * Math.ceil(w0 / 8) + Math.floor(x / 8);
+                    var alpha = (mask[idx] << (x % 8)) & 0x80 ? 255 : 0;
+                    if (cmap) {
+                        idx = (w0 * y) + x;
+                        var rgb = cmap[pixels[idx]];
+                        cur.push(rgb[2]);  // blue
+                        cur.push(rgb[1]);  // green
+                        cur.push(rgb[0]);  // red
+                        cur.push(alpha);   // alpha
+                    } else {
+                        idx = ((w0 * y) + x) * 4;
+                        cur.push(pixels[idx + 2]); // blue
+                        cur.push(pixels[idx + 1]); // green
+                        cur.push(pixels[idx]);     // red
+                        cur.push(alpha);           // alpha
+                    }
+                }
+            }
+        }
+
+        // XOR/bitmask data (BYTE icXOR[])
+        // (ignored, just needs to be the right size)
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < Math.ceil(w / 8); x++) {
+                cur.push(0);
+            }
+        }
+
+        // AND/bitmask data (BYTE icAND[])
+        // (ignored, just needs to be the right size)
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < Math.ceil(w / 8); x++) {
+                cur.push(0);
+            }
+        }
+
+        var url = 'data:image/x-icon;base64,' + Base64.encode(cur);
+        target.style.cursor = 'url(' + url + ')' + hotx + ' ' + hoty + ', default';
+    };
+})();

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/input.js

@@ -0,0 +1,388 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2012 Joel Martin
+ * Copyright (C) 2013 Samuel Mannehed for Cendio AB
+ * Licensed under MPL 2.0 or any later version (see LICENSE.txt)
+ */
+
+/*jslint browser: true, white: false */
+/*global window, Util */
+
+var Keyboard, Mouse;
+
+(function () {
+    "use strict";
+
+    //
+    // Keyboard event handler
+    //
+
+    Keyboard = function (defaults) {
+        this._keyDownList = [];         // List of depressed keys
+                                        // (even if they are happy)
+
+        Util.set_defaults(this, defaults, {
+            'target': document,
+            'focused': true
+        });
+
+        // create the keyboard handler
+        this._handler = new KeyEventDecoder(kbdUtil.ModifierSync(),
+            VerifyCharModifier( /* jshint newcap: false */
+                TrackKeyState(
+                    EscapeModifiers(this._handleRfbEvent.bind(this))
+                )
+            )
+        ); /* jshint newcap: true */
+
+        // keep these here so we can refer to them later
+        this._eventHandlers = {
+            'keyup': this._handleKeyUp.bind(this),
+            'keydown': this._handleKeyDown.bind(this),
+            'keypress': this._handleKeyPress.bind(this),
+            'blur': this._allKeysUp.bind(this)
+        };
+    };
+
+    Keyboard.prototype = {
+        // private methods
+
+        _handleRfbEvent: function (e) {
+            if (this._onKeyPress) {
+                Util.Debug("onKeyPress " + (e.type == 'keydown' ? "down" : "up") +
+                           ", keysym: " + e.keysym.keysym + "(" + e.keysym.keyname + ")");
+                this._onKeyPress(e.keysym.keysym, e.type == 'keydown');
+            }
+        },
+
+        _handleKeyDown: function (e) {
+            if (!this._focused) { return true; }
+
+            if (this._handler.keydown(e)) {
+                // Suppress bubbling/default actions
+                Util.stopEvent(e);
+                return false;
+            } else {
+                // Allow the event to bubble and become a keyPress event which
+                // will have the character code translated
+                return true;
+            }
+        },
+
+        _handleKeyPress: function (e) {
+            if (!this._focused) { return true; }
+
+            if (this._handler.keypress(e)) {
+                // Suppress bubbling/default actions
+                Util.stopEvent(e);
+                return false;
+            } else {
+                // Allow the event to bubble and become a keyPress event which
+                // will have the character code translated
+                return true;
+            }
+        },
+
+        _handleKeyUp: function (e) {
+            if (!this._focused) { return true; }
+
+            if (this._handler.keyup(e)) {
+                // Suppress bubbling/default actions
+                Util.stopEvent(e);
+                return false;
+            } else {
+                // Allow the event to bubble and become a keyPress event which
+                // will have the character code translated
+                return true;
+            }
+        },
+
+        _allKeysUp: function () {
+            Util.Debug(">> Keyboard.allKeysUp");
+            this._handler.releaseAll();
+            Util.Debug("<< Keyboard.allKeysUp");
+        },
+
+        // Public methods
+
+        grab: function () {
+            //Util.Debug(">> Keyboard.grab");
+            var c = this._target;
+
+            Util.addEvent(c, 'keydown', this._eventHandlers.keydown);
+            Util.addEvent(c, 'keyup', this._eventHandlers.keyup);
+            Util.addEvent(c, 'keypress', this._eventHandlers.keypress);
+
+            // Release (key up) if window loses focus
+            Util.addEvent(window, 'blur', this._eventHandlers.blur);
+
+            //Util.Debug("<< Keyboard.grab");
+        },
+
+        ungrab: function () {
+            //Util.Debug(">> Keyboard.ungrab");
+            var c = this._target;
+
+            Util.removeEvent(c, 'keydown', this._eventHandlers.keydown);
+            Util.removeEvent(c, 'keyup', this._eventHandlers.keyup);
+            Util.removeEvent(c, 'keypress', this._eventHandlers.keypress);
+            Util.removeEvent(window, 'blur', this._eventHandlers.blur);
+
+            // Release (key up) all keys that are in a down state
+            this._allKeysUp();
+
+            //Util.Debug(">> Keyboard.ungrab");
+        },
+
+        sync: function (e) {
+            this._handler.syncModifiers(e);
+        }
+    };
+
+    Util.make_properties(Keyboard, [
+        ['target',     'wo', 'dom'],  // DOM element that captures keyboard input
+        ['focused',    'rw', 'bool'], // Capture and send key events
+
+        ['onKeyPress', 'rw', 'func'] // Handler for key press/release
+    ]);
+
+    //
+    // Mouse event handler
+    //
+
+    Mouse = function (defaults) {
+        this._mouseCaptured  = false;
+
+        this._doubleClickTimer = null;
+        this._lastTouchPos = null;
+
+        // Configuration attributes
+        Util.set_defaults(this, defaults, {
+            'target': document,
+            'focused': true,
+            'scale': 1.0,
+            'touchButton': 1
+        });
+
+        this._eventHandlers = {
+            'mousedown': this._handleMouseDown.bind(this),
+            'mouseup': this._handleMouseUp.bind(this),
+            'mousemove': this._handleMouseMove.bind(this),
+            'mousewheel': this._handleMouseWheel.bind(this),
+            'mousedisable': this._handleMouseDisable.bind(this)
+        };
+    };
+
+    Mouse.prototype = {
+        // private methods
+        _captureMouse: function () {
+            // capturing the mouse ensures we get the mouseup event
+            if (this._target.setCapture) {
+                this._target.setCapture();
+            }
+
+            // some browsers give us mouseup events regardless,
+            // so if we never captured the mouse, we can disregard the event
+            this._mouseCaptured = true;
+        },
+
+        _releaseMouse: function () {
+            if (this._target.releaseCapture) {
+                this._target.releaseCapture();
+            }
+            this._mouseCaptured = false;
+        },
+
+        _resetDoubleClickTimer: function () {
+            this._doubleClickTimer = null;
+        },
+
+        _handleMouseButton: function (e, down) {
+            if (!this._focused) { return true; }
+
+            if (this._notify) {
+                this._notify(e);
+            }
+
+            var evt = (e ? e : window.event);
+            var pos = Util.getEventPosition(e, this._target, this._scale);
+
+            var bmask;
+            if (e.touches || e.changedTouches) {
+                // Touch device
+
+                // When two touches occur within 500 ms of each other and are
+                // closer than 20 pixels together a double click is triggered.
+                if (down == 1) {
+                    if (this._doubleClickTimer === null) {
+                        this._lastTouchPos = pos;
+                    } else {
+                        clearTimeout(this._doubleClickTimer);
+
+                        // When the distance between the two touches is small enough
+                        // force the position of the latter touch to the position of
+                        // the first.
+
+                        var xs = this._lastTouchPos.x - pos.x;
+                        var ys = this._lastTouchPos.y - pos.y;
+                        var d = Math.sqrt((xs * xs) + (ys * ys));
+
+                        // The goal is to trigger on a certain physical width, the
+                        // devicePixelRatio brings us a bit closer but is not optimal.
+                        if (d < 20 * window.devicePixelRatio) {
+                            pos = this._lastTouchPos;
+                        }
+                    }
+                    this._doubleClickTimer = setTimeout(this._resetDoubleClickTimer.bind(this), 500);
+                }
+                bmask = this._touchButton;
+                // If bmask is set
+            } else if (evt.which) {
+                /* everything except IE */
+                bmask = 1 << evt.button;
+            } else {
+                /* IE including 9 */
+                bmask = (evt.button & 0x1) +      // Left
+                        (evt.button & 0x2) * 2 +  // Right
+                        (evt.button & 0x4) / 2;   // Middle
+            }
+
+            if (this._onMouseButton) {
+                Util.Debug("onMouseButton " + (down ? "down" : "up") +
+                           ", x: " + pos.x + ", y: " + pos.y + ", bmask: " + bmask);
+                this._onMouseButton(pos.x, pos.y, down, bmask);
+            }
+            Util.stopEvent(e);
+            return false;
+        },
+
+        _handleMouseDown: function (e) {
+            this._captureMouse();
+            this._handleMouseButton(e, 1);
+        },
+
+        _handleMouseUp: function (e) {
+            if (!this._mouseCaptured) { return; }
+
+            this._handleMouseButton(e, 0);
+            this._releaseMouse();
+        },
+
+        _handleMouseWheel: function (e) {
+            if (!this._focused) { return true; }
+
+            if (this._notify) {
+                this._notify(e);
+            }
+
+            var evt = (e ? e : window.event);
+            var pos = Util.getEventPosition(e, this._target, this._scale);
+            var wheelData = evt.detail ? evt.detail * -1 : evt.wheelDelta / 40;
+            var bmask;
+            if (wheelData > 0) {
+                bmask = 1 << 3;
+            } else {
+                bmask = 1 << 4;
+            }
+
+            if (this._onMouseButton) {
+                this._onMouseButton(pos.x, pos.y, 1, bmask);
+                this._onMouseButton(pos.x, pos.y, 0, bmask);
+            }
+            Util.stopEvent(e);
+            return false;
+        },
+
+        _handleMouseMove: function (e) {
+            if (! this._focused) { return true; }
+
+            if (this._notify) {
+                this._notify(e);
+            }
+
+            var evt = (e ? e : window.event);
+            var pos = Util.getEventPosition(e, this._target, this._scale);
+            if (this._onMouseMove) {
+                this._onMouseMove(pos.x, pos.y);
+            }
+            Util.stopEvent(e);
+            return false;
+        },
+
+        _handleMouseDisable: function (e) {
+            if (!this._focused) { return true; }
+
+            var evt = (e ? e : window.event);
+            var pos = Util.getEventPosition(e, this._target, this._scale);
+
+            /* Stop propagation if inside canvas area */
+            if ((pos.realx >= 0) && (pos.realy >= 0) &&
+                (pos.realx < this._target.offsetWidth) &&
+                (pos.realy < this._target.offsetHeight)) {
+                //Util.Debug("mouse event disabled");
+                Util.stopEvent(e);
+                return false;
+            }
+
+            return true;
+        },
+
+
+        // Public methods
+        grab: function () {
+            var c = this._target;
+
+            if ('ontouchstart' in document.documentElement) {
+                Util.addEvent(c, 'touchstart', this._eventHandlers.mousedown);
+                Util.addEvent(window, 'touchend', this._eventHandlers.mouseup);
+                Util.addEvent(c, 'touchend', this._eventHandlers.mouseup);
+                Util.addEvent(c, 'touchmove', this._eventHandlers.mousemove);
+            } else {
+                Util.addEvent(c, 'mousedown', this._eventHandlers.mousedown);
+                Util.addEvent(window, 'mouseup', this._eventHandlers.mouseup);
+                Util.addEvent(c, 'mouseup', this._eventHandlers.mouseup);
+                Util.addEvent(c, 'mousemove', this._eventHandlers.mousemove);
+                Util.addEvent(c, (Util.Engine.gecko) ? 'DOMMouseScroll' : 'mousewheel',
+                              this._eventHandlers.mousewheel);
+            }
+
+            /* Work around right and middle click browser behaviors */
+            Util.addEvent(document, 'click', this._eventHandlers.mousedisable);
+            Util.addEvent(document.body, 'contextmenu', this._eventHandlers.mousedisable);
+        },
+
+        ungrab: function () {
+            var c = this._target;
+
+            if ('ontouchstart' in document.documentElement) {
+                Util.removeEvent(c, 'touchstart', this._eventHandlers.mousedown);
+                Util.removeEvent(window, 'touchend', this._eventHandlers.mouseup);
+                Util.removeEvent(c, 'touchend', this._eventHandlers.mouseup);
+                Util.removeEvent(c, 'touchmove', this._eventHandlers.mousemove);
+            } else {
+                Util.removeEvent(c, 'mousedown', this._eventHandlers.mousedown);
+                Util.removeEvent(window, 'mouseup', this._eventHandlers.mouseup);
+                Util.removeEvent(c, 'mouseup', this._eventHandlers.mouseup);
+                Util.removeEvent(c, 'mousemove', this._eventHandlers.mousemove);
+                Util.removeEvent(c, (Util.Engine.gecko) ? 'DOMMouseScroll' : 'mousewheel',
+                                 this._eventHandlers.mousewheel);
+            }
+
+            /* Work around right and middle click browser behaviors */
+            Util.removeEvent(document, 'click', this._eventHandlers.mousedisable);
+            Util.removeEvent(document.body, 'contextmenu', this._eventHandlers.mousedisable);
+
+        }
+    };
+
+    Util.make_properties(Mouse, [
+        ['target',         'ro', 'dom'],   // DOM element that captures mouse input
+        ['notify',         'ro', 'func'],  // Function to call to notify whenever a mouse event is received
+        ['focused',        'rw', 'bool'],  // Capture and send mouse clicks/movement
+        ['scale',          'rw', 'float'], // Viewport scale factor 0.0 - 1.0
+
+        ['onMouseButton',  'rw', 'func'],  // Handler for mouse button click/release
+        ['onMouseMove',    'rw', 'func'],  // Handler for mouse movement
+        ['touchButton',    'rw', 'int']    // Button mask (1, 2, 4) for touch devices (0 means ignore clicks)
+    ]);
+})();

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/jsunzip.js

@@ -0,0 +1,676 @@
+/*
+ * JSUnzip
+ *
+ * Copyright (c) 2011 by Erik Moller
+ * All Rights Reserved
+ *
+ * This software is provided 'as-is', without any express
+ * or implied warranty.  In no event will the authors be
+ * held liable for any damages arising from the use of
+ * this software.
+ *
+ * Permission is granted to anyone to use this software
+ * for any purpose, including commercial applications,
+ * and to alter it and redistribute it freely, subject to
+ * the following restrictions:
+ *
+ * 1. The origin of this software must not be
+ *    misrepresented; you must not claim that you
+ *    wrote the original software. If you use this
+ *    software in a product, an acknowledgment in
+ *    the product documentation would be appreciated
+ *    but is not required.
+ *
+ * 2. Altered source versions must be plainly marked
+ *    as such, and must not be misrepresented as
+ *    being the original software.
+ *
+ * 3. This notice may not be removed or altered from
+ *    any source distribution.
+ */
+ 
+var tinf;
+
+function JSUnzip() {
+
+    this.getInt = function(offset, size) {
+        switch (size) {
+        case 4:
+            return  (this.data.charCodeAt(offset + 3) & 0xff) << 24 | 
+                    (this.data.charCodeAt(offset + 2) & 0xff) << 16 | 
+                    (this.data.charCodeAt(offset + 1) & 0xff) << 8 | 
+                    (this.data.charCodeAt(offset + 0) & 0xff);
+            break;
+        case 2:
+            return  (this.data.charCodeAt(offset + 1) & 0xff) << 8 | 
+                    (this.data.charCodeAt(offset + 0) & 0xff);
+            break;
+        default:
+            return this.data.charCodeAt(offset) & 0xff;
+            break;
+        }
+    };
+
+    this.getDOSDate = function(dosdate, dostime) {
+        var day = dosdate & 0x1f;
+        var month = ((dosdate >> 5) & 0xf) - 1;
+        var year = 1980 + ((dosdate >> 9) & 0x7f)
+        var second = (dostime & 0x1f) * 2;
+        var minute = (dostime >> 5) & 0x3f;
+        hour = (dostime >> 11) & 0x1f;
+        return new Date(year, month, day, hour, minute, second);
+    }
+
+    this.open = function(data) {
+        this.data = data;
+        this.files = [];
+
+        if (this.data.length < 22)
+            return { 'status' : false, 'error' : 'Invalid data' };
+        var endOfCentralDirectory = this.data.length - 22;
+        while (endOfCentralDirectory >= 0 && this.getInt(endOfCentralDirectory, 4) != 0x06054b50)
+            --endOfCentralDirectory;
+        if (endOfCentralDirectory < 0)
+            return { 'status' : false, 'error' : 'Invalid data' };
+        if (this.getInt(endOfCentralDirectory + 4, 2) != 0 || this.getInt(endOfCentralDirectory + 6, 2) != 0)
+            return { 'status' : false, 'error' : 'No multidisk support' };
+
+        var entriesInThisDisk = this.getInt(endOfCentralDirectory + 8, 2);
+        var centralDirectoryOffset = this.getInt(endOfCentralDirectory + 16, 4);
+        var globalCommentLength = this.getInt(endOfCentralDirectory + 20, 2);
+        this.comment = this.data.slice(endOfCentralDirectory + 22, endOfCentralDirectory + 22 + globalCommentLength);
+
+        var fileOffset = centralDirectoryOffset;
+
+        for (var i = 0; i < entriesInThisDisk; ++i) {
+            if (this.getInt(fileOffset + 0, 4) != 0x02014b50)
+                return { 'status' : false, 'error' : 'Invalid data' };
+            if (this.getInt(fileOffset + 6, 2) > 20)
+                return { 'status' : false, 'error' : 'Unsupported version' };
+            if (this.getInt(fileOffset + 8, 2) & 1)
+                return { 'status' : false, 'error' : 'Encryption not implemented' };
+
+            var compressionMethod = this.getInt(fileOffset + 10, 2);
+            if (compressionMethod != 0 && compressionMethod != 8)
+                return { 'status' : false, 'error' : 'Unsupported compression method' };
+
+            var lastModFileTime = this.getInt(fileOffset + 12, 2);
+            var lastModFileDate = this.getInt(fileOffset + 14, 2);
+            var lastModifiedDate = this.getDOSDate(lastModFileDate, lastModFileTime);
+
+            var crc = this.getInt(fileOffset + 16, 4);
+            // TODO: crc
+
+            var compressedSize = this.getInt(fileOffset + 20, 4);
+            var uncompressedSize = this.getInt(fileOffset + 24, 4);
+
+            var fileNameLength = this.getInt(fileOffset + 28, 2);
+            var extraFieldLength = this.getInt(fileOffset + 30, 2);
+            var fileCommentLength = this.getInt(fileOffset + 32, 2);
+
+            var relativeOffsetOfLocalHeader = this.getInt(fileOffset + 42, 4);
+
+            var fileName = this.data.slice(fileOffset + 46, fileOffset + 46 + fileNameLength);
+            var fileComment = this.data.slice(fileOffset + 46 + fileNameLength + extraFieldLength, fileOffset + 46 + fileNameLength + extraFieldLength + fileCommentLength);
+
+            if (this.getInt(relativeOffsetOfLocalHeader + 0, 4) != 0x04034b50)
+                return { 'status' : false, 'error' : 'Invalid data' };
+            var localFileNameLength = this.getInt(relativeOffsetOfLocalHeader + 26, 2);
+            var localExtraFieldLength = this.getInt(relativeOffsetOfLocalHeader + 28, 2);
+            var localFileContent = relativeOffsetOfLocalHeader + 30 + localFileNameLength + localExtraFieldLength;
+
+            this.files[fileName] = 
+            {
+                'fileComment' : fileComment,
+                'compressionMethod' : compressionMethod,
+                'compressedSize' : compressedSize,
+                'uncompressedSize' : uncompressedSize,
+                'localFileContent' : localFileContent,
+                'lastModifiedDate' : lastModifiedDate
+            };
+
+            fileOffset += 46 + fileNameLength + extraFieldLength + fileCommentLength;
+        }
+        return { 'status' : true }
+    };     
+    
+
+    this.read = function(fileName) {
+        var fileInfo = this.files[fileName];
+        if (fileInfo) {
+            if (fileInfo.compressionMethod == 8) {
+                if (!tinf) {
+                    tinf = new TINF();
+                    tinf.init();
+                }
+                var result = tinf.uncompress(this.data, fileInfo.localFileContent);
+                if (result.status == tinf.OK)
+                    return { 'status' : true, 'data' : result.data };
+                else
+                    return { 'status' : false, 'error' : result.error };
+            } else {
+                return { 'status' : true, 'data' : this.data.slice(fileInfo.localFileContent, fileInfo.localFileContent + fileInfo.uncompressedSize) };
+            }
+        }
+        return { 'status' : false, 'error' : "File '" + fileName + "' doesn't exist in zip" };
+    };
+    
+};
+
+
+
+/*
+ * tinflate  -  tiny inflate
+ *
+ * Copyright (c) 2003 by Joergen Ibsen / Jibz
+ * All Rights Reserved
+ *
+ * http://www.ibsensoftware.com/
+ *
+ * This software is provided 'as-is', without any express
+ * or implied warranty.  In no event will the authors be
+ * held liable for any damages arising from the use of
+ * this software.
+ *
+ * Permission is granted to anyone to use this software
+ * for any purpose, including commercial applications,
+ * and to alter it and redistribute it freely, subject to
+ * the following restrictions:
+ *
+ * 1. The origin of this software must not be
+ *    misrepresented; you must not claim that you
+ *    wrote the original software. If you use this
+ *    software in a product, an acknowledgment in
+ *    the product documentation would be appreciated
+ *    but is not required.
+ *
+ * 2. Altered source versions must be plainly marked
+ *    as such, and must not be misrepresented as
+ *    being the original software.
+ *
+ * 3. This notice may not be removed or altered from
+ *    any source distribution.
+ */
+
+/*
+ * tinflate javascript port by Erik Moller in May 2011.
+ * emoller@opera.com
+ * 
+ * read_bits() patched by mike@imidio.com to allow
+ * reading more then 8 bits (needed in some zlib streams)
+ */
+
+"use strict";
+
+function TINF() {
+    
+this.OK = 0;
+this.DATA_ERROR = (-3);
+this.WINDOW_SIZE = 32768;
+
+/* ------------------------------ *
+ * -- internal data structures -- *
+ * ------------------------------ */
+
+this.TREE = function() {
+   this.table = new Array(16);  /* table of code length counts */
+   this.trans = new Array(288); /* code -> symbol translation table */
+};
+
+this.DATA = function(that) {
+   this.source = '';
+   this.sourceIndex = 0;
+   this.tag = 0;
+   this.bitcount = 0;
+
+   this.dest = [];
+   
+   this.history = [];
+
+   this.ltree = new that.TREE(); /* dynamic length/symbol tree */
+   this.dtree = new that.TREE(); /* dynamic distance tree */
+};
+
+/* --------------------------------------------------- *
+ * -- uninitialized global data (static structures) -- *
+ * --------------------------------------------------- */
+
+this.sltree = new this.TREE(); /* fixed length/symbol tree */
+this.sdtree = new this.TREE(); /* fixed distance tree */
+
+/* extra bits and base tables for length codes */
+this.length_bits = new Array(30);
+this.length_base = new Array(30);
+
+/* extra bits and base tables for distance codes */
+this.dist_bits = new Array(30);
+this.dist_base = new Array(30);
+
+/* special ordering of code length codes */
+this.clcidx = [
+   16, 17, 18, 0, 8, 7, 9, 6,
+   10, 5, 11, 4, 12, 3, 13, 2,
+   14, 1, 15
+];
+
+/* ----------------------- *
+ * -- utility functions -- *
+ * ----------------------- */
+
+/* build extra bits and base tables */
+this.build_bits_base = function(bits, base, delta, first)
+{
+   var i, sum;
+
+   /* build bits table */
+   for (i = 0; i < delta; ++i) bits[i] = 0;
+   for (i = 0; i < 30 - delta; ++i) bits[i + delta] = Math.floor(i / delta);
+
+   /* build base table */
+   for (sum = first, i = 0; i < 30; ++i)
+   {
+      base[i] = sum;
+      sum += 1 << bits[i];
+   }
+}
+
+/* build the fixed huffman trees */
+this.build_fixed_trees = function(lt, dt)
+{
+   var i;
+
+   /* build fixed length tree */
+   for (i = 0; i < 7; ++i) lt.table[i] = 0;
+
+   lt.table[7] = 24;
+   lt.table[8] = 152;
+   lt.table[9] = 112;
+
+   for (i = 0; i < 24; ++i) lt.trans[i] = 256 + i;
+   for (i = 0; i < 144; ++i) lt.trans[24 + i] = i;
+   for (i = 0; i < 8; ++i) lt.trans[24 + 144 + i] = 280 + i;
+   for (i = 0; i < 112; ++i) lt.trans[24 + 144 + 8 + i] = 144 + i;
+
+   /* build fixed distance tree */
+   for (i = 0; i < 5; ++i) dt.table[i] = 0;
+
+   dt.table[5] = 32;
+
+   for (i = 0; i < 32; ++i) dt.trans[i] = i;
+}
+
+/* given an array of code lengths, build a tree */
+this.build_tree = function(t, lengths, loffset, num)
+{
+   var offs = new Array(16);
+   var i, sum;
+
+   /* clear code length count table */
+   for (i = 0; i < 16; ++i) t.table[i] = 0;
+
+   /* scan symbol lengths, and sum code length counts */
+   for (i = 0; i < num; ++i) t.table[lengths[loffset + i]]++;
+
+   t.table[0] = 0;
+
+   /* compute offset table for distribution sort */
+   for (sum = 0, i = 0; i < 16; ++i)
+   {
+      offs[i] = sum;
+      sum += t.table[i];
+   }
+
+   /* create code->symbol translation table (symbols sorted by code) */
+   for (i = 0; i < num; ++i)
+   {
+      if (lengths[loffset + i]) t.trans[offs[lengths[loffset + i]]++] = i;
+   }
+}
+
+/* ---------------------- *
+ * -- decode functions -- *
+ * ---------------------- */
+
+/* get one bit from source stream */
+this.getbit = function(d)
+{
+   var bit;
+
+   /* check if tag is empty */
+   if (!d.bitcount--)
+   {
+      /* load next tag */
+      d.tag = d.source[d.sourceIndex++] & 0xff;
+      d.bitcount = 7;
+   }
+
+   /* shift bit out of tag */
+   bit = d.tag & 0x01;
+   d.tag >>= 1;
+
+   return bit;
+}
+
+/* read a num bit value from a stream and add base */
+function read_bits_direct(source, bitcount, tag, idx, num)
+{
+    var val = 0;
+    while (bitcount < 24) {
+        tag = tag | (source[idx++] & 0xff) << bitcount;
+        bitcount += 8;
+    }
+    val = tag & (0xffff >> (16 - num));
+    tag >>= num;
+    bitcount -= num;
+    return [bitcount, tag, idx, val];
+}
+this.read_bits = function(d, num, base)
+{
+    if (!num)
+        return base;
+
+    var ret = read_bits_direct(d.source, d.bitcount, d.tag, d.sourceIndex, num);
+    d.bitcount = ret[0];
+    d.tag = ret[1];
+    d.sourceIndex = ret[2];
+    return ret[3] + base;
+}
+
+/* given a data stream and a tree, decode a symbol */
+this.decode_symbol = function(d, t)
+{
+    while (d.bitcount < 16) {
+        d.tag = d.tag | (d.source[d.sourceIndex++] & 0xff) << d.bitcount;
+        d.bitcount += 8;
+    }
+    
+    var sum = 0, cur = 0, len = 0;
+    do {
+        cur = 2 * cur + ((d.tag & (1 << len)) >> len);
+
+        ++len;
+
+        sum += t.table[len];
+        cur -= t.table[len];
+
+    } while (cur >= 0);
+
+    d.tag >>= len;
+    d.bitcount -= len;
+
+    return t.trans[sum + cur];
+}
+
+/* given a data stream, decode dynamic trees from it */
+this.decode_trees = function(d, lt, dt)
+{
+   var code_tree = new this.TREE();
+   var lengths = new Array(288+32);
+   var hlit, hdist, hclen;
+   var i, num, length;
+
+   /* get 5 bits HLIT (257-286) */
+   hlit = this.read_bits(d, 5, 257);
+
+   /* get 5 bits HDIST (1-32) */
+   hdist = this.read_bits(d, 5, 1);
+
+   /* get 4 bits HCLEN (4-19) */
+   hclen = this.read_bits(d, 4, 4);
+
+   for (i = 0; i < 19; ++i) lengths[i] = 0;
+
+   /* read code lengths for code length alphabet */
+   for (i = 0; i < hclen; ++i)
+   {
+      /* get 3 bits code length (0-7) */
+      var clen = this.read_bits(d, 3, 0);
+
+      lengths[this.clcidx[i]] = clen;
+   }
+
+   /* build code length tree */
+   this.build_tree(code_tree, lengths, 0, 19);
+
+   /* decode code lengths for the dynamic trees */
+   for (num = 0; num < hlit + hdist; )
+   {
+      var sym = this.decode_symbol(d, code_tree);
+
+      switch (sym)
+      {
+      case 16:
+         /* copy previous code length 3-6 times (read 2 bits) */
+         {
+            var prev = lengths[num - 1];
+            for (length = this.read_bits(d, 2, 3); length; --length)
+            {
+               lengths[num++] = prev;
+            }
+         }
+         break;
+      case 17:
+         /* repeat code length 0 for 3-10 times (read 3 bits) */
+         for (length = this.read_bits(d, 3, 3); length; --length)
+         {
+            lengths[num++] = 0;
+         }
+         break;
+      case 18:
+         /* repeat code length 0 for 11-138 times (read 7 bits) */
+         for (length = this.read_bits(d, 7, 11); length; --length)
+         {
+            lengths[num++] = 0;
+         }
+         break;
+      default:
+         /* values 0-15 represent the actual code lengths */
+         lengths[num++] = sym;
+         break;
+      }
+   }
+
+   /* build dynamic trees */
+   this.build_tree(lt, lengths, 0, hlit);
+   this.build_tree(dt, lengths, hlit, hdist);
+}
+
+/* ----------------------------- *
+ * -- block inflate functions -- *
+ * ----------------------------- */
+
+/* given a stream and two trees, inflate a block of data */
+this.inflate_block_data = function(d, lt, dt)
+{
+   // js optimization.
+   var ddest = d.dest;
+   var ddestlength = ddest.length;
+
+   while (1)
+   {
+      var sym = this.decode_symbol(d, lt);
+
+      /* check for end of block */
+      if (sym == 256)
+      {
+         return this.OK;
+      }
+
+      if (sym < 256)
+      {
+         ddest[ddestlength++] = sym; // ? String.fromCharCode(sym);
+         d.history.push(sym);
+      } else {
+
+         var length, dist, offs;
+         var i;
+
+         sym -= 257;
+
+         /* possibly get more bits from length code */
+         length = this.read_bits(d, this.length_bits[sym], this.length_base[sym]);
+
+         dist = this.decode_symbol(d, dt);
+
+         /* possibly get more bits from distance code */
+         offs = d.history.length - this.read_bits(d, this.dist_bits[dist], this.dist_base[dist]);
+
+         if (offs < 0)
+             throw ("Invalid zlib offset " + offs);
+         
+         /* copy match */
+         for (i = offs; i < offs + length; ++i) {
+            //ddest[ddestlength++] = ddest[i];
+            ddest[ddestlength++] = d.history[i];
+            d.history.push(d.history[i]);
+         }
+      }
+   }
+}
+
+/* inflate an uncompressed block of data */
+this.inflate_uncompressed_block = function(d)
+{
+   var length, invlength;
+   var i;
+
+   if (d.bitcount > 7) {
+       var overflow = Math.floor(d.bitcount / 8);
+       d.sourceIndex -= overflow;
+       d.bitcount = 0;
+       d.tag = 0;
+   }
+   
+   /* get length */
+   length = d.source[d.sourceIndex+1];
+   length = 256*length + d.source[d.sourceIndex];
+
+   /* get one's complement of length */
+   invlength = d.source[d.sourceIndex+3];
+   invlength = 256*invlength + d.source[d.sourceIndex+2];
+
+   /* check length */
+   if (length != (~invlength & 0x0000ffff)) return this.DATA_ERROR;
+
+   d.sourceIndex += 4;
+
+   /* copy block */
+   for (i = length; i; --i) {
+       d.history.push(d.source[d.sourceIndex]);
+       d.dest[d.dest.length] = d.source[d.sourceIndex++];
+   }
+
+   /* make sure we start next block on a byte boundary */
+   d.bitcount = 0;
+
+   return this.OK;
+}
+
+/* inflate a block of data compressed with fixed huffman trees */
+this.inflate_fixed_block = function(d)
+{
+   /* decode block using fixed trees */
+   return this.inflate_block_data(d, this.sltree, this.sdtree);
+}
+
+/* inflate a block of data compressed with dynamic huffman trees */
+this.inflate_dynamic_block = function(d)
+{
+   /* decode trees from stream */
+   this.decode_trees(d, d.ltree, d.dtree);
+
+   /* decode block using decoded trees */
+   return this.inflate_block_data(d, d.ltree, d.dtree);
+}
+
+/* ---------------------- *
+ * -- public functions -- *
+ * ---------------------- */
+
+/* initialize global (static) data */
+this.init = function()
+{
+   /* build fixed huffman trees */
+   this.build_fixed_trees(this.sltree, this.sdtree);
+
+   /* build extra bits and base tables */
+   this.build_bits_base(this.length_bits, this.length_base, 4, 3);
+   this.build_bits_base(this.dist_bits, this.dist_base, 2, 1);
+
+   /* fix a special case */
+   this.length_bits[28] = 0;
+   this.length_base[28] = 258;
+
+   this.reset();   
+}
+
+this.reset = function()
+{
+   this.d = new this.DATA(this);
+   delete this.header;
+}
+
+/* inflate stream from source to dest */
+this.uncompress = function(source, offset)
+{
+
+   var d = this.d;
+   var bfinal;
+
+   /* initialise data */
+   d.source = source;
+   d.sourceIndex = offset;
+   d.bitcount = 0;
+
+   d.dest = [];
+
+   // Skip zlib header at start of stream
+   if (typeof this.header == 'undefined') {
+       this.header = this.read_bits(d, 16, 0);
+       /* byte 0: 0x78, 7 = 32k window size, 8 = deflate */
+       /* byte 1: check bits for header and other flags */
+   }
+
+   var blocks = 0;
+   
+   do {
+
+      var btype;
+      var res;
+
+      /* read final block flag */
+      bfinal = this.getbit(d);
+
+      /* read block type (2 bits) */
+      btype = this.read_bits(d, 2, 0);
+
+      /* decompress block */
+      switch (btype)
+      {
+      case 0:
+         /* decompress uncompressed block */
+         res = this.inflate_uncompressed_block(d);
+         break;
+      case 1:
+         /* decompress block with fixed huffman trees */
+         res = this.inflate_fixed_block(d);
+         break;
+      case 2:
+         /* decompress block with dynamic huffman trees */
+         res = this.inflate_dynamic_block(d);
+         break;
+      default:
+         return { 'status' : this.DATA_ERROR };
+      }
+
+      if (res != this.OK) return { 'status' : this.DATA_ERROR };
+      blocks++;
+      
+   } while (!bfinal && d.sourceIndex < d.source.length);
+
+   d.history = d.history.slice(-this.WINDOW_SIZE);
+   
+   return { 'status' : this.OK, 'data' : d.dest };
+}
+
+};

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/keyboard.js

@@ -0,0 +1,543 @@
+var kbdUtil = (function() {
+    "use strict";
+
+    function substituteCodepoint(cp) {
+        // Any Unicode code points which do not have corresponding keysym entries
+        // can be swapped out for another code point by adding them to this table
+        var substitutions = {
+            // {S,s} with comma below -> {S,s} with cedilla
+            0x218 : 0x15e,
+            0x219 : 0x15f,
+            // {T,t} with comma below -> {T,t} with cedilla
+            0x21a : 0x162,
+            0x21b : 0x163
+        };
+
+        var sub = substitutions[cp];
+        return sub ? sub : cp;
+    }
+
+    function isMac() {
+        return navigator && !!(/mac/i).exec(navigator.platform);
+    }
+    function isWindows() {
+        return navigator && !!(/win/i).exec(navigator.platform);
+    }
+    function isLinux() {
+        return navigator && !!(/linux/i).exec(navigator.platform);
+    }
+
+    // Return true if a modifier which is not the specified char modifier (and is not shift) is down
+    function hasShortcutModifier(charModifier, currentModifiers) {
+        var mods = {};
+        for (var key in currentModifiers) {
+            if (parseInt(key) !== XK_Shift_L) {
+                mods[key] = currentModifiers[key];
+            }
+        }
+
+        var sum = 0;
+        for (var k in currentModifiers) {
+            if (mods[k]) {
+                ++sum;
+            }
+        }
+        if (hasCharModifier(charModifier, mods)) {
+            return sum > charModifier.length;
+        }
+        else {
+            return sum > 0;
+        }
+    }
+
+    // Return true if the specified char modifier is currently down
+    function hasCharModifier(charModifier, currentModifiers) {
+        if (charModifier.length === 0) { return false; }
+
+        for (var i = 0; i < charModifier.length; ++i) {
+            if (!currentModifiers[charModifier[i]]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // Helper object tracking modifier key state
+    // and generates fake key events to compensate if it gets out of sync
+    function ModifierSync(charModifier) {
+        if (!charModifier) {
+            if (isMac()) {
+                // on Mac, Option (AKA Alt) is used as a char modifier
+                charModifier = [XK_Alt_L];
+            }
+            else if (isWindows()) {
+                // on Windows, Ctrl+Alt is used as a char modifier
+                charModifier = [XK_Alt_L, XK_Control_L];
+            }
+            else if (isLinux()) {
+                // on Linux, ISO Level 3 Shift (AltGr) is used as a char modifier
+                charModifier = [XK_ISO_Level3_Shift];
+            }
+            else {
+                charModifier = [];
+            }
+        }
+
+        var state = {};
+        state[XK_Control_L] = false;
+        state[XK_Alt_L] = false;
+        state[XK_ISO_Level3_Shift] = false;
+        state[XK_Shift_L] = false;
+        state[XK_Meta_L] = false;
+
+        function sync(evt, keysym) {
+            var result = [];
+            function syncKey(keysym) {
+                return {keysym: keysyms.lookup(keysym), type: state[keysym] ? 'keydown' : 'keyup'};
+            }
+
+            if (evt.ctrlKey !== undefined &&
+                evt.ctrlKey !== state[XK_Control_L] && keysym !== XK_Control_L) {
+                state[XK_Control_L] = evt.ctrlKey;
+                result.push(syncKey(XK_Control_L));
+            }
+            if (evt.altKey !== undefined &&
+                evt.altKey !== state[XK_Alt_L] && keysym !== XK_Alt_L) {
+                state[XK_Alt_L] = evt.altKey;
+                result.push(syncKey(XK_Alt_L));
+            }
+            if (evt.altGraphKey !== undefined &&
+                evt.altGraphKey !== state[XK_ISO_Level3_Shift] && keysym !== XK_ISO_Level3_Shift) {
+                state[XK_ISO_Level3_Shift] = evt.altGraphKey;
+                result.push(syncKey(XK_ISO_Level3_Shift));
+            }
+            if (evt.shiftKey !== undefined &&
+                evt.shiftKey !== state[XK_Shift_L] && keysym !== XK_Shift_L) {
+                state[XK_Shift_L] = evt.shiftKey;
+                result.push(syncKey(XK_Shift_L));
+            }
+            if (evt.metaKey !== undefined &&
+                evt.metaKey !== state[XK_Meta_L] && keysym !== XK_Meta_L) {
+                state[XK_Meta_L] = evt.metaKey;
+                result.push(syncKey(XK_Meta_L));
+            }
+            return result;
+        }
+        function syncKeyEvent(evt, down) {
+            var obj = getKeysym(evt);
+            var keysym = obj ? obj.keysym : null;
+
+            // first, apply the event itself, if relevant
+            if (keysym !== null && state[keysym] !== undefined) {
+                state[keysym] = down;
+            }
+            return sync(evt, keysym);
+        }
+
+        return {
+            // sync on the appropriate keyboard event
+            keydown: function(evt) { return syncKeyEvent(evt, true);},
+            keyup: function(evt) { return syncKeyEvent(evt, false);},
+            // Call this with a non-keyboard event (such as mouse events) to use its modifier state to synchronize anyway
+            syncAny: function(evt) { return sync(evt);},
+
+            // is a shortcut modifier down?
+            hasShortcutModifier: function() { return hasShortcutModifier(charModifier, state); },
+            // if a char modifier is down, return the keys it consists of, otherwise return null
+            activeCharModifier: function() { return hasCharModifier(charModifier, state) ? charModifier : null; }
+        };
+    }
+
+    // Get a key ID from a keyboard event
+    // May be a string or an integer depending on the available properties
+    function getKey(evt){
+        if ('keyCode' in evt && 'key' in evt) {
+            return evt.key + ':' + evt.keyCode;
+        }
+        else if ('keyCode' in evt) {
+            return evt.keyCode;
+        }
+        else {
+            return evt.key;
+        }
+    }
+
+    // Get the most reliable keysym value we can get from a key event
+    // if char/charCode is available, prefer those, otherwise fall back to key/keyCode/which
+    function getKeysym(evt){
+        var codepoint;
+        if (evt.char && evt.char.length === 1) {
+            codepoint = evt.char.charCodeAt();
+        }
+        else if (evt.charCode) {
+            codepoint = evt.charCode;
+        }
+        else if (evt.keyCode && evt.type === 'keypress') {
+            // IE10 stores the char code as keyCode, and has no other useful properties
+            codepoint = evt.keyCode;
+        }
+        if (codepoint) {
+            var res = keysyms.fromUnicode(substituteCodepoint(codepoint));
+            if (res) {
+                return res;
+            }
+        }
+        // we could check evt.key here.
+        // Legal values are defined in http://www.w3.org/TR/DOM-Level-3-Events/#key-values-list,
+        // so we "just" need to map them to keysym, but AFAIK this is only available in IE10, which also provides evt.key
+        // so we don't *need* it yet
+        if (evt.keyCode) {
+            return keysyms.lookup(keysymFromKeyCode(evt.keyCode, evt.shiftKey));
+        }
+        if (evt.which) {
+            return keysyms.lookup(keysymFromKeyCode(evt.which, evt.shiftKey));
+        }
+        return null;
+    }
+
+    // Given a keycode, try to predict which keysym it might be.
+    // If the keycode is unknown, null is returned.
+    function keysymFromKeyCode(keycode, shiftPressed) {
+        if (typeof(keycode) !== 'number') {
+            return null;
+        }
+        // won't be accurate for azerty
+        if (keycode >= 0x30 && keycode <= 0x39) {
+            return keycode; // digit
+        }
+        if (keycode >= 0x41 && keycode <= 0x5a) {
+            // remap to lowercase unless shift is down
+            return shiftPressed ? keycode : keycode + 32; // A-Z
+        }
+        if (keycode >= 0x60 && keycode <= 0x69) {
+            return XK_KP_0 + (keycode - 0x60); // numpad 0-9
+        }
+
+        switch(keycode) {
+            case 0x20: return XK_space;
+            case 0x6a: return XK_KP_Multiply;
+            case 0x6b: return XK_KP_Add;
+            case 0x6c: return XK_KP_Separator;
+            case 0x6d: return XK_KP_Subtract;
+            case 0x6e: return XK_KP_Decimal;
+            case 0x6f: return XK_KP_Divide;
+            case 0xbb: return XK_plus;
+            case 0xbc: return XK_comma;
+            case 0xbd: return XK_minus;
+            case 0xbe: return XK_period;
+        }
+
+        return nonCharacterKey({keyCode: keycode});
+    }
+
+    // if the key is a known non-character key (any key which doesn't generate character data)
+    // return its keysym value. Otherwise return null
+    function nonCharacterKey(evt) {
+        // evt.key not implemented yet
+        if (!evt.keyCode) { return null; }
+        var keycode = evt.keyCode;
+
+        if (keycode >= 0x70 && keycode <= 0x87) {
+            return XK_F1 + keycode - 0x70; // F1-F24
+        }
+        switch (keycode) {
+
+            case 8 : return XK_BackSpace;
+            case 13 : return XK_Return;
+
+            case 9 : return XK_Tab;
+
+            case 27 : return XK_Escape;
+            case 46 : return XK_Delete;
+
+            case 36 : return XK_Home;
+            case 35 : return XK_End;
+            case 33 : return XK_Page_Up;
+            case 34 : return XK_Page_Down;
+            case 45 : return XK_Insert;
+
+            case 37 : return XK_Left;
+            case 38 : return XK_Up;
+            case 39 : return XK_Right;
+            case 40 : return XK_Down;
+
+            case 16 : return XK_Shift_L;
+            case 17 : return XK_Control_L;
+            case 18 : return XK_Alt_L; // also: Option-key on Mac
+
+            case 224 : return XK_Meta_L;
+            case 225 : return XK_ISO_Level3_Shift; // AltGr
+            case 91 : return XK_Super_L; // also: Windows-key
+            case 92 : return XK_Super_R; // also: Windows-key
+            case 93 : return XK_Menu; // also: Windows-Menu, Command on Mac
+            default: return null;
+        }
+    }
+    return {
+        hasShortcutModifier : hasShortcutModifier,
+        hasCharModifier : hasCharModifier,
+        ModifierSync : ModifierSync,
+        getKey : getKey,
+        getKeysym : getKeysym,
+        keysymFromKeyCode : keysymFromKeyCode,
+        nonCharacterKey : nonCharacterKey,
+        substituteCodepoint : substituteCodepoint
+    };
+})();
+
+// Takes a DOM keyboard event and:
+// - determines which keysym it represents
+// - determines a keyId  identifying the key that was pressed (corresponding to the key/keyCode properties on the DOM event)
+// - synthesizes events to synchronize modifier key state between which modifiers are actually down, and which we thought were down
+// - marks each event with an 'escape' property if a modifier was down which should be "escaped"
+// - generates a "stall" event in cases where it might be necessary to wait and see if a keypress event follows a keydown
+// This information is collected into an object which is passed to the next() function. (one call per event)
+function KeyEventDecoder(modifierState, next) {
+    "use strict";
+    function sendAll(evts) {
+        for (var i = 0; i < evts.length; ++i) {
+            next(evts[i]);
+        }
+    }
+    function process(evt, type) {
+        var result = {type: type};
+        var keyId = kbdUtil.getKey(evt);
+        if (keyId) {
+            result.keyId = keyId;
+        }
+
+        var keysym = kbdUtil.getKeysym(evt);
+
+        var hasModifier = modifierState.hasShortcutModifier() || !!modifierState.activeCharModifier();
+        // Is this a case where we have to decide on the keysym right away, rather than waiting for the keypress?
+        // "special" keys like enter, tab or backspace don't send keypress events,
+        // and some browsers don't send keypresses at all if a modifier is down
+        if (keysym && (type !== 'keydown' || kbdUtil.nonCharacterKey(evt) || hasModifier)) {
+            result.keysym = keysym;
+        }
+
+        var isShift = evt.keyCode === 0x10 || evt.key === 'Shift';
+
+        // Should we prevent the browser from handling the event?
+        // Doing so on a keydown (in most browsers) prevents keypress from being generated
+        // so only do that if we have to.
+        var suppress = !isShift && (type !== 'keydown' || modifierState.hasShortcutModifier() || !!kbdUtil.nonCharacterKey(evt));
+
+        // If a char modifier is down on a keydown, we need to insert a stall,
+        // so VerifyCharModifier knows to wait and see if a keypress is comnig
+        var stall = type === 'keydown' && modifierState.activeCharModifier() && !kbdUtil.nonCharacterKey(evt);
+
+        // if a char modifier is pressed, get the keys it consists of (on Windows, AltGr is equivalent to Ctrl+Alt)
+        var active = modifierState.activeCharModifier();
+
+        // If we have a char modifier down, and we're able to determine a keysym reliably
+        // then (a) we know to treat the modifier as a char modifier,
+        // and (b) we'll have to "escape" the modifier to undo the modifier when sending the char.
+        if (active && keysym) {
+            var isCharModifier = false;
+            for (var i  = 0; i < active.length; ++i) {
+                if (active[i] === keysym.keysym) {
+                    isCharModifier = true;
+                }
+            }
+            if (type === 'keypress' && !isCharModifier) {
+                result.escape = modifierState.activeCharModifier();
+            }
+        }
+
+        if (stall) {
+            // insert a fake "stall" event
+            next({type: 'stall'});
+        }
+        next(result);
+
+        return suppress;
+    }
+
+    return {
+        keydown: function(evt) {
+            sendAll(modifierState.keydown(evt));
+            return process(evt, 'keydown');
+        },
+        keypress: function(evt) {
+            return process(evt, 'keypress');
+        },
+        keyup: function(evt) {
+            sendAll(modifierState.keyup(evt));
+            return process(evt, 'keyup');
+        },
+        syncModifiers: function(evt) {
+            sendAll(modifierState.syncAny(evt));
+        },
+        releaseAll: function() { next({type: 'releaseall'}); }
+    };
+}
+
+// Combines keydown and keypress events where necessary to handle char modifiers.
+// On some OS'es, a char modifier is sometimes used as a shortcut modifier.
+// For example, on Windows, AltGr is synonymous with Ctrl-Alt. On a Danish keyboard layout, AltGr-2 yields a @, but Ctrl-Alt-D does nothing
+// so when used with the '2' key, Ctrl-Alt counts as a char modifier (and should be escaped), but when used with 'D', it does not.
+// The only way we can distinguish these cases is to wait and see if a keypress event arrives
+// When we receive a "stall" event, wait a few ms before processing the next keydown. If a keypress has also arrived, merge the two
+function VerifyCharModifier(next) {
+    "use strict";
+    var queue = [];
+    var timer = null;
+    function process() {
+        if (timer) {
+            return;
+        }
+
+        var delayProcess = function () {
+            clearTimeout(timer);
+            timer = null;
+            process();
+        };
+
+        while (queue.length !== 0) {
+            var cur = queue[0];
+            queue = queue.splice(1);
+            switch (cur.type) {
+            case 'stall':
+                // insert a delay before processing available events.
+                /* jshint loopfunc: true */
+                timer = setTimeout(delayProcess, 5);
+                /* jshint loopfunc: false */
+                return;
+            case 'keydown':
+                // is the next element a keypress? Then we should merge the two
+                if (queue.length !== 0 && queue[0].type === 'keypress') {
+                    // Firefox sends keypress even when no char is generated.
+                    // so, if keypress keysym is the same as we'd have guessed from keydown,
+                    // the modifier didn't have any effect, and should not be escaped
+                    if (queue[0].escape && (!cur.keysym || cur.keysym.keysym !== queue[0].keysym.keysym)) {
+                        cur.escape = queue[0].escape;
+                    }
+                    cur.keysym = queue[0].keysym;
+                    queue = queue.splice(1);
+                }
+                break;
+            }
+
+            // swallow stall events, and pass all others to the next stage
+            if (cur.type !== 'stall') {
+                next(cur);
+            }
+        }
+    }
+    return function(evt) {
+        queue.push(evt);
+        process();
+    };
+}
+
+// Keeps track of which keys we (and the server) believe are down
+// When a keyup is received, match it against this list, to determine the corresponding keysym(s)
+// in some cases, a single key may produce multiple keysyms, so the corresponding keyup event must release all of these chars
+// key repeat events should be merged into a single entry.
+// Because we can't always identify which entry a keydown or keyup event corresponds to, we sometimes have to guess
+function TrackKeyState(next) {
+    "use strict";
+    var state = [];
+
+    return function (evt) {
+        var last = state.length !== 0 ? state[state.length-1] : null;
+
+        switch (evt.type) {
+        case 'keydown':
+            // insert a new entry if last seen key was different.
+            if (!last || !evt.keyId || last.keyId !== evt.keyId) {
+                last = {keyId: evt.keyId, keysyms: {}};
+                state.push(last);
+            }
+            if (evt.keysym) {
+                // make sure last event contains this keysym (a single "logical" keyevent
+                // can cause multiple key events to be sent to the VNC server)
+                last.keysyms[evt.keysym.keysym] = evt.keysym;
+                last.ignoreKeyPress = true;
+                next(evt);
+            }
+            break;
+        case 'keypress':
+            if (!last) {
+                last = {keyId: evt.keyId, keysyms: {}};
+                state.push(last);
+            }
+            if (!evt.keysym) {
+                console.log('keypress with no keysym:', evt);
+            }
+
+            // If we didn't expect a keypress, and already sent a keydown to the VNC server
+            // based on the keydown, make sure to skip this event.
+            if (evt.keysym && !last.ignoreKeyPress) {
+                last.keysyms[evt.keysym.keysym] = evt.keysym;
+                evt.type = 'keydown';
+                next(evt);
+            }
+            break;
+        case 'keyup':
+            if (state.length === 0) {
+                return;
+            }
+            var idx = null;
+            // do we have a matching key tracked as being down?
+            for (var i = 0; i !== state.length; ++i) {
+                if (state[i].keyId === evt.keyId) {
+                    idx = i;
+                    break;
+                }
+            }
+            // if we couldn't find a match (it happens), assume it was the last key pressed
+            if (idx === null) {
+                idx = state.length - 1;
+            }
+
+            var item = state.splice(idx, 1)[0];
+            // for each keysym tracked by this key entry, clone the current event and override the keysym
+            var clone = (function(){
+                function Clone(){}
+                return function (obj) { Clone.prototype=obj; return new Clone(); };
+            }());
+            for (var key in item.keysyms) {
+                var out = clone(evt);
+                out.keysym = item.keysyms[key];
+                next(out);
+            }
+            break;
+        case 'releaseall':
+            /* jshint shadow: true */
+            for (var i = 0; i < state.length; ++i) {
+                for (var key in state[i].keysyms) {
+                    var keysym = state[i].keysyms[key];
+                    next({keyId: 0, keysym: keysym, type: 'keyup'});
+                }
+            }
+            /* jshint shadow: false */
+            state = [];
+        }
+    };
+}
+
+// Handles "escaping" of modifiers: if a char modifier is used to produce a keysym (such as AltGr-2 to generate an @),
+// then the modifier must be "undone" before sending the @, and "redone" afterwards.
+function EscapeModifiers(next) {
+    "use strict";
+    return function(evt) {
+        if (evt.type !== 'keydown' || evt.escape === undefined) {
+            next(evt);
+            return;
+        }
+        // undo modifiers
+        for (var i = 0; i < evt.escape.length; ++i) {
+            next({type: 'keyup', keyId: 0, keysym: keysyms.lookup(evt.escape[i])});
+        }
+        // send the character event
+        next(evt);
+        // redo modifiers
+        /* jshint shadow: true */
+        for (var i = 0; i < evt.escape.length; ++i) {
+            next({type: 'keydown', keyId: 0, keysym: keysyms.lookup(evt.escape[i])});
+        }
+        /* jshint shadow: false */
+    };
+}

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/keysym.js

@@ -0,0 +1,378 @@
+var XK_VoidSymbol =                0xffffff, /* Void symbol */
+
+XK_BackSpace =                   0xff08, /* Back space, back char */
+XK_Tab =                         0xff09,
+XK_Linefeed =                    0xff0a, /* Linefeed, LF */
+XK_Clear =                       0xff0b,
+XK_Return =                      0xff0d, /* Return, enter */
+XK_Pause =                       0xff13, /* Pause, hold */
+XK_Scroll_Lock =                 0xff14,
+XK_Sys_Req =                     0xff15,
+XK_Escape =                      0xff1b,
+XK_Delete =                      0xffff, /* Delete, rubout */
+
+/* Cursor control & motion */
+
+XK_Home =                        0xff50,
+XK_Left =                        0xff51, /* Move left, left arrow */
+XK_Up =                          0xff52, /* Move up, up arrow */
+XK_Right =                       0xff53, /* Move right, right arrow */
+XK_Down =                        0xff54, /* Move down, down arrow */
+XK_Prior =                       0xff55, /* Prior, previous */
+XK_Page_Up =                     0xff55,
+XK_Next =                        0xff56, /* Next */
+XK_Page_Down =                   0xff56,
+XK_End =                         0xff57, /* EOL */
+XK_Begin =                       0xff58, /* BOL */
+
+
+/* Misc functions */
+
+XK_Select =                      0xff60, /* Select, mark */
+XK_Print =                       0xff61,
+XK_Execute =                     0xff62, /* Execute, run, do */
+XK_Insert =                      0xff63, /* Insert, insert here */
+XK_Undo =                        0xff65,
+XK_Redo =                        0xff66, /* Redo, again */
+XK_Menu =                        0xff67,
+XK_Find =                        0xff68, /* Find, search */
+XK_Cancel =                      0xff69, /* Cancel, stop, abort, exit */
+XK_Help =                        0xff6a, /* Help */
+XK_Break =                       0xff6b,
+XK_Mode_switch =                 0xff7e, /* Character set switch */
+XK_script_switch =               0xff7e, /* Alias for mode_switch */
+XK_Num_Lock =                    0xff7f,
+
+/* Keypad functions, keypad numbers cleverly chosen to map to ASCII */
+
+XK_KP_Space =                    0xff80, /* Space */
+XK_KP_Tab =                      0xff89,
+XK_KP_Enter =                    0xff8d, /* Enter */
+XK_KP_F1 =                       0xff91, /* PF1, KP_A, ... */
+XK_KP_F2 =                       0xff92,
+XK_KP_F3 =                       0xff93,
+XK_KP_F4 =                       0xff94,
+XK_KP_Home =                     0xff95,
+XK_KP_Left =                     0xff96,
+XK_KP_Up =                       0xff97,
+XK_KP_Right =                    0xff98,
+XK_KP_Down =                     0xff99,
+XK_KP_Prior =                    0xff9a,
+XK_KP_Page_Up =                  0xff9a,
+XK_KP_Next =                     0xff9b,
+XK_KP_Page_Down =                0xff9b,
+XK_KP_End =                      0xff9c,
+XK_KP_Begin =                    0xff9d,
+XK_KP_Insert =                   0xff9e,
+XK_KP_Delete =                   0xff9f,
+XK_KP_Equal =                    0xffbd, /* Equals */
+XK_KP_Multiply =                 0xffaa,
+XK_KP_Add =                      0xffab,
+XK_KP_Separator =                0xffac, /* Separator, often comma */
+XK_KP_Subtract =                 0xffad,
+XK_KP_Decimal =                  0xffae,
+XK_KP_Divide =                   0xffaf,
+
+XK_KP_0 =                        0xffb0,
+XK_KP_1 =                        0xffb1,
+XK_KP_2 =                        0xffb2,
+XK_KP_3 =                        0xffb3,
+XK_KP_4 =                        0xffb4,
+XK_KP_5 =                        0xffb5,
+XK_KP_6 =                        0xffb6,
+XK_KP_7 =                        0xffb7,
+XK_KP_8 =                        0xffb8,
+XK_KP_9 =                        0xffb9,
+
+/*
+ * Auxiliary functions; note the duplicate definitions for left and right
+ * function keys;  Sun keyboards and a few other manufacturers have such
+ * function key groups on the left and/or right sides of the keyboard.
+ * We've not found a keyboard with more than 35 function keys total.
+ */
+
+XK_F1 =                          0xffbe,
+XK_F2 =                          0xffbf,
+XK_F3 =                          0xffc0,
+XK_F4 =                          0xffc1,
+XK_F5 =                          0xffc2,
+XK_F6 =                          0xffc3,
+XK_F7 =                          0xffc4,
+XK_F8 =                          0xffc5,
+XK_F9 =                          0xffc6,
+XK_F10 =                         0xffc7,
+XK_F11 =                         0xffc8,
+XK_L1 =                          0xffc8,
+XK_F12 =                         0xffc9,
+XK_L2 =                          0xffc9,
+XK_F13 =                         0xffca,
+XK_L3 =                          0xffca,
+XK_F14 =                         0xffcb,
+XK_L4 =                          0xffcb,
+XK_F15 =                         0xffcc,
+XK_L5 =                          0xffcc,
+XK_F16 =                         0xffcd,
+XK_L6 =                          0xffcd,
+XK_F17 =                         0xffce,
+XK_L7 =                          0xffce,
+XK_F18 =                         0xffcf,
+XK_L8 =                          0xffcf,
+XK_F19 =                         0xffd0,
+XK_L9 =                          0xffd0,
+XK_F20 =                         0xffd1,
+XK_L10 =                         0xffd1,
+XK_F21 =                         0xffd2,
+XK_R1 =                          0xffd2,
+XK_F22 =                         0xffd3,
+XK_R2 =                          0xffd3,
+XK_F23 =                         0xffd4,
+XK_R3 =                          0xffd4,
+XK_F24 =                         0xffd5,
+XK_R4 =                          0xffd5,
+XK_F25 =                         0xffd6,
+XK_R5 =                          0xffd6,
+XK_F26 =                         0xffd7,
+XK_R6 =                          0xffd7,
+XK_F27 =                         0xffd8,
+XK_R7 =                          0xffd8,
+XK_F28 =                         0xffd9,
+XK_R8 =                          0xffd9,
+XK_F29 =                         0xffda,
+XK_R9 =                          0xffda,
+XK_F30 =                         0xffdb,
+XK_R10 =                         0xffdb,
+XK_F31 =                         0xffdc,
+XK_R11 =                         0xffdc,
+XK_F32 =                         0xffdd,
+XK_R12 =                         0xffdd,
+XK_F33 =                         0xffde,
+XK_R13 =                         0xffde,
+XK_F34 =                         0xffdf,
+XK_R14 =                         0xffdf,
+XK_F35 =                         0xffe0,
+XK_R15 =                         0xffe0,
+
+/* Modifiers */
+
+XK_Shift_L =                     0xffe1, /* Left shift */
+XK_Shift_R =                     0xffe2, /* Right shift */
+XK_Control_L =                   0xffe3, /* Left control */
+XK_Control_R =                   0xffe4, /* Right control */
+XK_Caps_Lock =                   0xffe5, /* Caps lock */
+XK_Shift_Lock =                  0xffe6, /* Shift lock */
+
+XK_Meta_L =                      0xffe7, /* Left meta */
+XK_Meta_R =                      0xffe8, /* Right meta */
+XK_Alt_L =                       0xffe9, /* Left alt */
+XK_Alt_R =                       0xffea, /* Right alt */
+XK_Super_L =                     0xffeb, /* Left super */
+XK_Super_R =                     0xffec, /* Right super */
+XK_Hyper_L =                     0xffed, /* Left hyper */
+XK_Hyper_R =                     0xffee, /* Right hyper */
+
+XK_ISO_Level3_Shift =            0xfe03, /* AltGr */
+
+/*
+ * Latin 1
+ * (ISO/IEC 8859-1 = Unicode U+0020..U+00FF)
+ * Byte 3 = 0
+ */
+
+XK_space =                       0x0020, /* U+0020 SPACE */
+XK_exclam =                      0x0021, /* U+0021 EXCLAMATION MARK */
+XK_quotedbl =                    0x0022, /* U+0022 QUOTATION MARK */
+XK_numbersign =                  0x0023, /* U+0023 NUMBER SIGN */
+XK_dollar =                      0x0024, /* U+0024 DOLLAR SIGN */
+XK_percent =                     0x0025, /* U+0025 PERCENT SIGN */
+XK_ampersand =                   0x0026, /* U+0026 AMPERSAND */
+XK_apostrophe =                  0x0027, /* U+0027 APOSTROPHE */
+XK_quoteright =                  0x0027, /* deprecated */
+XK_parenleft =                   0x0028, /* U+0028 LEFT PARENTHESIS */
+XK_parenright =                  0x0029, /* U+0029 RIGHT PARENTHESIS */
+XK_asterisk =                    0x002a, /* U+002A ASTERISK */
+XK_plus =                        0x002b, /* U+002B PLUS SIGN */
+XK_comma =                       0x002c, /* U+002C COMMA */
+XK_minus =                       0x002d, /* U+002D HYPHEN-MINUS */
+XK_period =                      0x002e, /* U+002E FULL STOP */
+XK_slash =                       0x002f, /* U+002F SOLIDUS */
+XK_0 =                           0x0030, /* U+0030 DIGIT ZERO */
+XK_1 =                           0x0031, /* U+0031 DIGIT ONE */
+XK_2 =                           0x0032, /* U+0032 DIGIT TWO */
+XK_3 =                           0x0033, /* U+0033 DIGIT THREE */
+XK_4 =                           0x0034, /* U+0034 DIGIT FOUR */
+XK_5 =                           0x0035, /* U+0035 DIGIT FIVE */
+XK_6 =                           0x0036, /* U+0036 DIGIT SIX */
+XK_7 =                           0x0037, /* U+0037 DIGIT SEVEN */
+XK_8 =                           0x0038, /* U+0038 DIGIT EIGHT */
+XK_9 =                           0x0039, /* U+0039 DIGIT NINE */
+XK_colon =                       0x003a, /* U+003A COLON */
+XK_semicolon =                   0x003b, /* U+003B SEMICOLON */
+XK_less =                        0x003c, /* U+003C LESS-THAN SIGN */
+XK_equal =                       0x003d, /* U+003D EQUALS SIGN */
+XK_greater =                     0x003e, /* U+003E GREATER-THAN SIGN */
+XK_question =                    0x003f, /* U+003F QUESTION MARK */
+XK_at =                          0x0040, /* U+0040 COMMERCIAL AT */
+XK_A =                           0x0041, /* U+0041 LATIN CAPITAL LETTER A */
+XK_B =                           0x0042, /* U+0042 LATIN CAPITAL LETTER B */
+XK_C =                           0x0043, /* U+0043 LATIN CAPITAL LETTER C */
+XK_D =                           0x0044, /* U+0044 LATIN CAPITAL LETTER D */
+XK_E =                           0x0045, /* U+0045 LATIN CAPITAL LETTER E */
+XK_F =                           0x0046, /* U+0046 LATIN CAPITAL LETTER F */
+XK_G =                           0x0047, /* U+0047 LATIN CAPITAL LETTER G */
+XK_H =                           0x0048, /* U+0048 LATIN CAPITAL LETTER H */
+XK_I =                           0x0049, /* U+0049 LATIN CAPITAL LETTER I */
+XK_J =                           0x004a, /* U+004A LATIN CAPITAL LETTER J */
+XK_K =                           0x004b, /* U+004B LATIN CAPITAL LETTER K */
+XK_L =                           0x004c, /* U+004C LATIN CAPITAL LETTER L */
+XK_M =                           0x004d, /* U+004D LATIN CAPITAL LETTER M */
+XK_N =                           0x004e, /* U+004E LATIN CAPITAL LETTER N */
+XK_O =                           0x004f, /* U+004F LATIN CAPITAL LETTER O */
+XK_P =                           0x0050, /* U+0050 LATIN CAPITAL LETTER P */
+XK_Q =                           0x0051, /* U+0051 LATIN CAPITAL LETTER Q */
+XK_R =                           0x0052, /* U+0052 LATIN CAPITAL LETTER R */
+XK_S =                           0x0053, /* U+0053 LATIN CAPITAL LETTER S */
+XK_T =                           0x0054, /* U+0054 LATIN CAPITAL LETTER T */
+XK_U =                           0x0055, /* U+0055 LATIN CAPITAL LETTER U */
+XK_V =                           0x0056, /* U+0056 LATIN CAPITAL LETTER V */
+XK_W =                           0x0057, /* U+0057 LATIN CAPITAL LETTER W */
+XK_X =                           0x0058, /* U+0058 LATIN CAPITAL LETTER X */
+XK_Y =                           0x0059, /* U+0059 LATIN CAPITAL LETTER Y */
+XK_Z =                           0x005a, /* U+005A LATIN CAPITAL LETTER Z */
+XK_bracketleft =                 0x005b, /* U+005B LEFT SQUARE BRACKET */
+XK_backslash =                   0x005c, /* U+005C REVERSE SOLIDUS */
+XK_bracketright =                0x005d, /* U+005D RIGHT SQUARE BRACKET */
+XK_asciicircum =                 0x005e, /* U+005E CIRCUMFLEX ACCENT */
+XK_underscore =                  0x005f, /* U+005F LOW LINE */
+XK_grave =                       0x0060, /* U+0060 GRAVE ACCENT */
+XK_quoteleft =                   0x0060, /* deprecated */
+XK_a =                           0x0061, /* U+0061 LATIN SMALL LETTER A */
+XK_b =                           0x0062, /* U+0062 LATIN SMALL LETTER B */
+XK_c =                           0x0063, /* U+0063 LATIN SMALL LETTER C */
+XK_d =                           0x0064, /* U+0064 LATIN SMALL LETTER D */
+XK_e =                           0x0065, /* U+0065 LATIN SMALL LETTER E */
+XK_f =                           0x0066, /* U+0066 LATIN SMALL LETTER F */
+XK_g =                           0x0067, /* U+0067 LATIN SMALL LETTER G */
+XK_h =                           0x0068, /* U+0068 LATIN SMALL LETTER H */
+XK_i =                           0x0069, /* U+0069 LATIN SMALL LETTER I */
+XK_j =                           0x006a, /* U+006A LATIN SMALL LETTER J */
+XK_k =                           0x006b, /* U+006B LATIN SMALL LETTER K */
+XK_l =                           0x006c, /* U+006C LATIN SMALL LETTER L */
+XK_m =                           0x006d, /* U+006D LATIN SMALL LETTER M */
+XK_n =                           0x006e, /* U+006E LATIN SMALL LETTER N */
+XK_o =                           0x006f, /* U+006F LATIN SMALL LETTER O */
+XK_p =                           0x0070, /* U+0070 LATIN SMALL LETTER P */
+XK_q =                           0x0071, /* U+0071 LATIN SMALL LETTER Q */
+XK_r =                           0x0072, /* U+0072 LATIN SMALL LETTER R */
+XK_s =                           0x0073, /* U+0073 LATIN SMALL LETTER S */
+XK_t =                           0x0074, /* U+0074 LATIN SMALL LETTER T */
+XK_u =                           0x0075, /* U+0075 LATIN SMALL LETTER U */
+XK_v =                           0x0076, /* U+0076 LATIN SMALL LETTER V */
+XK_w =                           0x0077, /* U+0077 LATIN SMALL LETTER W */
+XK_x =                           0x0078, /* U+0078 LATIN SMALL LETTER X */
+XK_y =                           0x0079, /* U+0079 LATIN SMALL LETTER Y */
+XK_z =                           0x007a, /* U+007A LATIN SMALL LETTER Z */
+XK_braceleft =                   0x007b, /* U+007B LEFT CURLY BRACKET */
+XK_bar =                         0x007c, /* U+007C VERTICAL LINE */
+XK_braceright =                  0x007d, /* U+007D RIGHT CURLY BRACKET */
+XK_asciitilde =                  0x007e, /* U+007E TILDE */
+
+XK_nobreakspace =                0x00a0, /* U+00A0 NO-BREAK SPACE */
+XK_exclamdown =                  0x00a1, /* U+00A1 INVERTED EXCLAMATION MARK */
+XK_cent =                        0x00a2, /* U+00A2 CENT SIGN */
+XK_sterling =                    0x00a3, /* U+00A3 POUND SIGN */
+XK_currency =                    0x00a4, /* U+00A4 CURRENCY SIGN */
+XK_yen =                         0x00a5, /* U+00A5 YEN SIGN */
+XK_brokenbar =                   0x00a6, /* U+00A6 BROKEN BAR */
+XK_section =                     0x00a7, /* U+00A7 SECTION SIGN */
+XK_diaeresis =                   0x00a8, /* U+00A8 DIAERESIS */
+XK_copyright =                   0x00a9, /* U+00A9 COPYRIGHT SIGN */
+XK_ordfeminine =                 0x00aa, /* U+00AA FEMININE ORDINAL INDICATOR */
+XK_guillemotleft =               0x00ab, /* U+00AB LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
+XK_notsign =                     0x00ac, /* U+00AC NOT SIGN */
+XK_hyphen =                      0x00ad, /* U+00AD SOFT HYPHEN */
+XK_registered =                  0x00ae, /* U+00AE REGISTERED SIGN */
+XK_macron =                      0x00af, /* U+00AF MACRON */
+XK_degree =                      0x00b0, /* U+00B0 DEGREE SIGN */
+XK_plusminus =                   0x00b1, /* U+00B1 PLUS-MINUS SIGN */
+XK_twosuperior =                 0x00b2, /* U+00B2 SUPERSCRIPT TWO */
+XK_threesuperior =               0x00b3, /* U+00B3 SUPERSCRIPT THREE */
+XK_acute =                       0x00b4, /* U+00B4 ACUTE ACCENT */
+XK_mu =                          0x00b5, /* U+00B5 MICRO SIGN */
+XK_paragraph =                   0x00b6, /* U+00B6 PILCROW SIGN */
+XK_periodcentered =              0x00b7, /* U+00B7 MIDDLE DOT */
+XK_cedilla =                     0x00b8, /* U+00B8 CEDILLA */
+XK_onesuperior =                 0x00b9, /* U+00B9 SUPERSCRIPT ONE */
+XK_masculine =                   0x00ba, /* U+00BA MASCULINE ORDINAL INDICATOR */
+XK_guillemotright =              0x00bb, /* U+00BB RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
+XK_onequarter =                  0x00bc, /* U+00BC VULGAR FRACTION ONE QUARTER */
+XK_onehalf =                     0x00bd, /* U+00BD VULGAR FRACTION ONE HALF */
+XK_threequarters =               0x00be, /* U+00BE VULGAR FRACTION THREE QUARTERS */
+XK_questiondown =                0x00bf, /* U+00BF INVERTED QUESTION MARK */
+XK_Agrave =                      0x00c0, /* U+00C0 LATIN CAPITAL LETTER A WITH GRAVE */
+XK_Aacute =                      0x00c1, /* U+00C1 LATIN CAPITAL LETTER A WITH ACUTE */
+XK_Acircumflex =                 0x00c2, /* U+00C2 LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
+XK_Atilde =                      0x00c3, /* U+00C3 LATIN CAPITAL LETTER A WITH TILDE */
+XK_Adiaeresis =                  0x00c4, /* U+00C4 LATIN CAPITAL LETTER A WITH DIAERESIS */
+XK_Aring =                       0x00c5, /* U+00C5 LATIN CAPITAL LETTER A WITH RING ABOVE */
+XK_AE =                          0x00c6, /* U+00C6 LATIN CAPITAL LETTER AE */
+XK_Ccedilla =                    0x00c7, /* U+00C7 LATIN CAPITAL LETTER C WITH CEDILLA */
+XK_Egrave =                      0x00c8, /* U+00C8 LATIN CAPITAL LETTER E WITH GRAVE */
+XK_Eacute =                      0x00c9, /* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
+XK_Ecircumflex =                 0x00ca, /* U+00CA LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
+XK_Ediaeresis =                  0x00cb, /* U+00CB LATIN CAPITAL LETTER E WITH DIAERESIS */
+XK_Igrave =                      0x00cc, /* U+00CC LATIN CAPITAL LETTER I WITH GRAVE */
+XK_Iacute =                      0x00cd, /* U+00CD LATIN CAPITAL LETTER I WITH ACUTE */
+XK_Icircumflex =                 0x00ce, /* U+00CE LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
+XK_Idiaeresis =                  0x00cf, /* U+00CF LATIN CAPITAL LETTER I WITH DIAERESIS */
+XK_ETH =                         0x00d0, /* U+00D0 LATIN CAPITAL LETTER ETH */
+XK_Eth =                         0x00d0, /* deprecated */
+XK_Ntilde =                      0x00d1, /* U+00D1 LATIN CAPITAL LETTER N WITH TILDE */
+XK_Ograve =                      0x00d2, /* U+00D2 LATIN CAPITAL LETTER O WITH GRAVE */
+XK_Oacute =                      0x00d3, /* U+00D3 LATIN CAPITAL LETTER O WITH ACUTE */
+XK_Ocircumflex =                 0x00d4, /* U+00D4 LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
+XK_Otilde =                      0x00d5, /* U+00D5 LATIN CAPITAL LETTER O WITH TILDE */
+XK_Odiaeresis =                  0x00d6, /* U+00D6 LATIN CAPITAL LETTER O WITH DIAERESIS */
+XK_multiply =                    0x00d7, /* U+00D7 MULTIPLICATION SIGN */
+XK_Oslash =                      0x00d8, /* U+00D8 LATIN CAPITAL LETTER O WITH STROKE */
+XK_Ooblique =                    0x00d8, /* U+00D8 LATIN CAPITAL LETTER O WITH STROKE */
+XK_Ugrave =                      0x00d9, /* U+00D9 LATIN CAPITAL LETTER U WITH GRAVE */
+XK_Uacute =                      0x00da, /* U+00DA LATIN CAPITAL LETTER U WITH ACUTE */
+XK_Ucircumflex =                 0x00db, /* U+00DB LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
+XK_Udiaeresis =                  0x00dc, /* U+00DC LATIN CAPITAL LETTER U WITH DIAERESIS */
+XK_Yacute =                      0x00dd, /* U+00DD LATIN CAPITAL LETTER Y WITH ACUTE */
+XK_THORN =                       0x00de, /* U+00DE LATIN CAPITAL LETTER THORN */
+XK_Thorn =                       0x00de, /* deprecated */
+XK_ssharp =                      0x00df, /* U+00DF LATIN SMALL LETTER SHARP S */
+XK_agrave =                      0x00e0, /* U+00E0 LATIN SMALL LETTER A WITH GRAVE */
+XK_aacute =                      0x00e1, /* U+00E1 LATIN SMALL LETTER A WITH ACUTE */
+XK_acircumflex =                 0x00e2, /* U+00E2 LATIN SMALL LETTER A WITH CIRCUMFLEX */
+XK_atilde =                      0x00e3, /* U+00E3 LATIN SMALL LETTER A WITH TILDE */
+XK_adiaeresis =                  0x00e4, /* U+00E4 LATIN SMALL LETTER A WITH DIAERESIS */
+XK_aring =                       0x00e5, /* U+00E5 LATIN SMALL LETTER A WITH RING ABOVE */
+XK_ae =                          0x00e6, /* U+00E6 LATIN SMALL LETTER AE */
+XK_ccedilla =                    0x00e7, /* U+00E7 LATIN SMALL LETTER C WITH CEDILLA */
+XK_egrave =                      0x00e8, /* U+00E8 LATIN SMALL LETTER E WITH GRAVE */
+XK_eacute =                      0x00e9, /* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
+XK_ecircumflex =                 0x00ea, /* U+00EA LATIN SMALL LETTER E WITH CIRCUMFLEX */
+XK_ediaeresis =                  0x00eb, /* U+00EB LATIN SMALL LETTER E WITH DIAERESIS */
+XK_igrave =                      0x00ec, /* U+00EC LATIN SMALL LETTER I WITH GRAVE */
+XK_iacute =                      0x00ed, /* U+00ED LATIN SMALL LETTER I WITH ACUTE */
+XK_icircumflex =                 0x00ee, /* U+00EE LATIN SMALL LETTER I WITH CIRCUMFLEX */
+XK_idiaeresis =                  0x00ef, /* U+00EF LATIN SMALL LETTER I WITH DIAERESIS */
+XK_eth =                         0x00f0, /* U+00F0 LATIN SMALL LETTER ETH */
+XK_ntilde =                      0x00f1, /* U+00F1 LATIN SMALL LETTER N WITH TILDE */
+XK_ograve =                      0x00f2, /* U+00F2 LATIN SMALL LETTER O WITH GRAVE */
+XK_oacute =                      0x00f3, /* U+00F3 LATIN SMALL LETTER O WITH ACUTE */
+XK_ocircumflex =                 0x00f4, /* U+00F4 LATIN SMALL LETTER O WITH CIRCUMFLEX */
+XK_otilde =                      0x00f5, /* U+00F5 LATIN SMALL LETTER O WITH TILDE */
+XK_odiaeresis =                  0x00f6, /* U+00F6 LATIN SMALL LETTER O WITH DIAERESIS */
+XK_division =                    0x00f7, /* U+00F7 DIVISION SIGN */
+XK_oslash =                      0x00f8, /* U+00F8 LATIN SMALL LETTER O WITH STROKE */
+XK_ooblique =                    0x00f8, /* U+00F8 LATIN SMALL LETTER O WITH STROKE */
+XK_ugrave =                      0x00f9, /* U+00F9 LATIN SMALL LETTER U WITH GRAVE */
+XK_uacute =                      0x00fa, /* U+00FA LATIN SMALL LETTER U WITH ACUTE */
+XK_ucircumflex =                 0x00fb, /* U+00FB LATIN SMALL LETTER U WITH CIRCUMFLEX */
+XK_udiaeresis =                  0x00fc, /* U+00FC LATIN SMALL LETTER U WITH DIAERESIS */
+XK_yacute =                      0x00fd, /* U+00FD LATIN SMALL LETTER Y WITH ACUTE */
+XK_thorn =                       0x00fe, /* U+00FE LATIN SMALL LETTER THORN */
+XK_ydiaeresis =                  0x00ff; /* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/playback.js

@@ -0,0 +1,102 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2012 Joel Martin
+ * Licensed under MPL 2.0 (see LICENSE.txt)
+ */
+
+"use strict";
+/*jslint browser: true, white: false */
+/*global Util, VNC_frame_data, finish */
+
+var rfb, mode, test_state, frame_idx, frame_length,
+    iteration, iterations, istart_time,
+
+    // Pre-declarations for jslint
+    send_array, next_iteration, queue_next_packet, do_packet;
+
+// Override send_array
+send_array = function (arr) {
+    // Stub out send_array
+};
+
+next_iteration = function () {
+    if (iteration === 0) {
+        frame_length = VNC_frame_data.length;
+        test_state = 'running';
+    } else {
+        rfb.disconnect();
+    }
+    
+    if (test_state !== 'running') { return; }
+
+    iteration += 1;
+    if (iteration > iterations) {
+        finish();
+        return;
+    }
+
+    frame_idx = 0;
+    istart_time = (new Date()).getTime();
+    rfb.connect('test', 0, "bogus");
+
+    queue_next_packet();
+
+};
+
+queue_next_packet = function () {
+    var frame, foffset, toffset, delay;
+    if (test_state !== 'running') { return; }
+
+    frame = VNC_frame_data[frame_idx];
+    while ((frame_idx < frame_length) && (frame.charAt(0) === "}")) {
+        //Util.Debug("Send frame " + frame_idx);
+        frame_idx += 1;
+        frame = VNC_frame_data[frame_idx];
+    }
+
+    if (frame === 'EOF') {
+        Util.Debug("Finished, found EOF");
+        next_iteration();
+        return;
+    }
+    if (frame_idx >= frame_length) {
+        Util.Debug("Finished, no more frames");
+        next_iteration();
+        return;
+    }
+
+    if (mode === 'realtime') {
+        foffset = frame.slice(1, frame.indexOf('{', 1));
+        toffset = (new Date()).getTime() - istart_time;
+        delay = foffset - toffset;
+        if (delay < 1) {
+            delay = 1;
+        }
+
+        setTimeout(do_packet, delay);
+    } else {
+        setTimeout(do_packet, 1);
+    }
+};
+
+var bytes_processed = 0;
+
+do_packet = function () {
+    //Util.Debug("Processing frame: " + frame_idx);
+    var frame = VNC_frame_data[frame_idx],
+        start = frame.indexOf('{', 1) + 1;
+    bytes_processed += frame.length - start;
+    if (VNC_frame_encoding === 'binary') {
+        var u8 = new Uint8Array(frame.length - start);
+        for (var i = 0; i < frame.length - start; i++) {
+            u8[i] = frame.charCodeAt(start + i);
+        }
+        rfb.recv_message({'data' : u8});
+    } else {
+        rfb.recv_message({'data' : frame.slice(start)});
+    }
+    frame_idx += 1;
+
+    queue_next_packet();
+};
+

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/util.js

@@ -0,0 +1,622 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2012 Joel Martin
+ * Licensed under MPL 2.0 (see LICENSE.txt)
+ *
+ * See README.md for usage and integration instructions.
+ */
+
+/* jshint white: false, nonstandard: true */
+/*global window, console, document, navigator, ActiveXObject, INCLUDE_URI */
+
+// Globals defined here
+var Util = {};
+
+
+/*
+ * Make arrays quack
+ */
+
+var addFunc = function (cl, name, func) {
+    if (!cl.prototype[name]) {
+        Object.defineProperty(cl.prototype, name, { enumerable: false, value: func });
+    }
+};
+
+addFunc(Array, 'push8', function (num) {
+    "use strict";
+    this.push(num & 0xFF);
+});
+
+addFunc(Array, 'push16', function (num) {
+    "use strict";
+    this.push((num >> 8) & 0xFF,
+              num & 0xFF);
+});
+
+addFunc(Array, 'push32', function (num) {
+    "use strict";
+    this.push((num >> 24) & 0xFF,
+              (num >> 16) & 0xFF,
+              (num >>  8) & 0xFF,
+              num & 0xFF);
+});
+
+// IE does not support map (even in IE9)
+//This prototype is provided by the Mozilla foundation and
+//is distributed under the MIT license.
+//http://www.ibiblio.org/pub/Linux/LICENSES/mit.license
+addFunc(Array, 'map', function (fun /*, thisp*/) {
+    "use strict";
+    var len = this.length;
+    if (typeof fun != "function") {
+        throw new TypeError();
+    }
+
+    var res = new Array(len);
+    var thisp = arguments[1];
+    for (var i = 0; i < len; i++) {
+        if (i in this) {
+            res[i] = fun.call(thisp, this[i], i, this);
+        }
+    }
+
+    return res;
+});
+
+// IE <9 does not support indexOf
+//This prototype is provided by the Mozilla foundation and
+//is distributed under the MIT license.
+//http://www.ibiblio.org/pub/Linux/LICENSES/mit.license
+addFunc(Array, 'indexOf', function (elt /*, from*/) {
+    "use strict";
+    var len = this.length >>> 0;
+
+    var from = Number(arguments[1]) || 0;
+    from = (from < 0) ? Math.ceil(from) : Math.floor(from);
+    if (from < 0) {
+        from += len;
+    }
+
+    for (; from < len; from++) {
+        if (from in this &&
+                this[from] === elt) {
+            return from;
+        }
+    }
+    return -1;
+});
+
+// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
+if (!Object.keys) {
+    Object.keys = (function () {
+        'use strict';
+        var hasOwnProperty = Object.prototype.hasOwnProperty,
+            hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
+            dontEnums = [
+                'toString',
+                'toLocaleString',
+                'valueOf',
+                'hasOwnProperty',
+                'isPrototypeOf',
+                'propertyIsEnumerable',
+                'constructor'
+            ],
+            dontEnumsLength = dontEnums.length;
+
+        return function (obj) {
+            if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {
+                throw new TypeError('Object.keys called on non-object');
+            }
+
+            var result = [], prop, i;
+
+            for (prop in obj) {
+                if (hasOwnProperty.call(obj, prop)) {
+                    result.push(prop);
+                }
+            }
+
+            if (hasDontEnumBug) {
+                for (i = 0; i < dontEnumsLength; i++) {
+                    if (hasOwnProperty.call(obj, dontEnums[i])) {
+                        result.push(dontEnums[i]);
+                    }
+                }
+            }
+            return result;
+        };
+    })();
+}
+
+// PhantomJS 1.x doesn't support bind,
+// so leave this in until PhantomJS 2.0 is released
+//This prototype is provided by the Mozilla foundation and
+//is distributed under the MIT license.
+//http://www.ibiblio.org/pub/Linux/LICENSES/mit.license
+addFunc(Function, 'bind', function (oThis) {
+    if (typeof this !== "function") {
+        // closest thing possible to the ECMAScript 5
+        // internal IsCallable function
+        throw new TypeError("Function.prototype.bind - " +
+                            "what is trying to be bound is not callable");
+    }
+
+    var aArgs = Array.prototype.slice.call(arguments, 1),
+            fToBind = this,
+            fNOP = function () {},
+            fBound = function () {
+                return fToBind.apply(this instanceof fNOP && oThis ? this
+                                                                   : oThis,
+                                     aArgs.concat(Array.prototype.slice.call(arguments)));
+            };
+
+    fNOP.prototype = this.prototype;
+    fBound.prototype = new fNOP();
+
+    return fBound;
+});
+
+//
+// requestAnimationFrame shim with setTimeout fallback
+//
+
+window.requestAnimFrame = (function () {
+    "use strict";
+    return  window.requestAnimationFrame       ||
+            window.webkitRequestAnimationFrame ||
+            window.mozRequestAnimationFrame    ||
+            window.oRequestAnimationFrame      ||
+            window.msRequestAnimationFrame     ||
+            function (callback) {
+                window.setTimeout(callback, 1000 / 60);
+            };
+})();
+
+/*
+ * ------------------------------------------------------
+ * Namespaced in Util
+ * ------------------------------------------------------
+ */
+
+/*
+ * Logging/debug routines
+ */
+
+Util._log_level = 'warn';
+Util.init_logging = function (level) {
+    "use strict";
+    if (typeof level === 'undefined') {
+        level = Util._log_level;
+    } else {
+        Util._log_level = level;
+    }
+    if (typeof window.console === "undefined") {
+        if (typeof window.opera !== "undefined") {
+            window.console = {
+                'log'  : window.opera.postError,
+                'warn' : window.opera.postError,
+                'error': window.opera.postError
+            };
+        } else {
+            window.console = {
+                'log'  : function (m) {},
+                'warn' : function (m) {},
+                'error': function (m) {}
+            };
+        }
+    }
+
+    Util.Debug = Util.Info = Util.Warn = Util.Error = function (msg) {};
+    /* jshint -W086 */
+    switch (level) {
+        case 'debug':
+            Util.Debug = function (msg) { console.log(msg); };
+        case 'info':
+            Util.Info  = function (msg) { console.log(msg); };
+        case 'warn':
+            Util.Warn  = function (msg) { console.warn(msg); };
+        case 'error':
+            Util.Error = function (msg) { console.error(msg); };
+        case 'none':
+            break;
+        default:
+            throw new Error("invalid logging type '" + level + "'");
+    }
+    /* jshint +W086 */
+};
+Util.get_logging = function () {
+    return Util._log_level;
+};
+// Initialize logging level
+Util.init_logging();
+
+Util.make_property = function (proto, name, mode, type) {
+    "use strict";
+
+    var getter;
+    if (type === 'arr') {
+        getter = function (idx) {
+            if (typeof idx !== 'undefined') {
+                return this['_' + name][idx];
+            } else {
+                return this['_' + name];
+            }
+        };
+    } else {
+        getter = function () {
+            return this['_' + name];
+        };
+    }
+
+    var make_setter = function (process_val) {
+        if (process_val) {
+            return function (val, idx) {
+                if (typeof idx !== 'undefined') {
+                    this['_' + name][idx] = process_val(val);
+                } else {
+                    this['_' + name] = process_val(val);
+                }
+            };
+        } else {
+            return function (val, idx) {
+                if (typeof idx !== 'undefined') {
+                    this['_' + name][idx] = val;
+                } else {
+                    this['_' + name] = val;
+                }
+            };
+        }
+    };
+
+    var setter;
+    if (type === 'bool') {
+        setter = make_setter(function (val) {
+            if (!val || (val in {'0': 1, 'no': 1, 'false': 1})) {
+                return false;
+            } else {
+                return true;
+            }
+        });
+    } else if (type === 'int') {
+        setter = make_setter(function (val) { return parseInt(val, 10); });
+    } else if (type === 'float') {
+        setter = make_setter(parseFloat);
+    } else if (type === 'str') {
+        setter = make_setter(String);
+    } else if (type === 'func') {
+        setter = make_setter(function (val) {
+            if (!val) {
+                return function () {};
+            } else {
+                return val;
+            }
+        });
+    } else if (type === 'arr' || type === 'dom' || type == 'raw') {
+        setter = make_setter();
+    } else {
+        throw new Error('Unknown property type ' + type);  // some sanity checking
+    }
+
+    // set the getter
+    if (typeof proto['get_' + name] === 'undefined') {
+        proto['get_' + name] = getter;
+    }
+
+    // set the setter if needed
+    if (typeof proto['set_' + name] === 'undefined') {
+        if (mode === 'rw') {
+            proto['set_' + name] = setter;
+        } else if (mode === 'wo') {
+            proto['set_' + name] = function (val, idx) {
+                if (typeof this['_' + name] !== 'undefined') {
+                    throw new Error(name + " can only be set once");
+                }
+                setter.call(this, val, idx);
+            };
+        }
+    }
+
+    // make a special setter that we can use in set defaults
+    proto['_raw_set_' + name] = function (val, idx) {
+        setter.call(this, val, idx);
+        //delete this['_init_set_' + name];  // remove it after use
+    };
+};
+
+Util.make_properties = function (constructor, arr) {
+    "use strict";
+    for (var i = 0; i < arr.length; i++) {
+        Util.make_property(constructor.prototype, arr[i][0], arr[i][1], arr[i][2]);
+    }
+};
+
+Util.set_defaults = function (obj, conf, defaults) {
+    var defaults_keys = Object.keys(defaults);
+    var conf_keys = Object.keys(conf);
+    var keys_obj = {};
+    var i;
+    for (i = 0; i < defaults_keys.length; i++) { keys_obj[defaults_keys[i]] = 1; }
+    for (i = 0; i < conf_keys.length; i++) { keys_obj[conf_keys[i]] = 1; }
+    var keys = Object.keys(keys_obj);
+
+    for (i = 0; i < keys.length; i++) {
+        var setter = obj['_raw_set_' + keys[i]];
+        if (!setter) {
+          Util.Warn('Invalid property ' + keys[i]);
+          continue;
+        }
+
+        if (keys[i] in conf) {
+            setter.call(obj, conf[keys[i]]);
+        } else {
+            setter.call(obj, defaults[keys[i]]);
+        }
+    }
+};
+
+/*
+ * Decode from UTF-8
+ */
+Util.decodeUTF8 = function (utf8string) {
+    "use strict";
+    return decodeURIComponent(escape(utf8string));
+};
+
+
+
+/*
+ * Cross-browser routines
+ */
+
+
+// Dynamically load scripts without using document.write()
+// Reference: http://unixpapa.com/js/dyna.html
+//
+// Handles the case where load_scripts is invoked from a script that
+// itself is loaded via load_scripts. Once all scripts are loaded the
+// window.onscriptsloaded handler is called (if set).
+Util.get_include_uri = function () {
+    return (typeof INCLUDE_URI !== "undefined") ? INCLUDE_URI : "include/";
+};
+Util._loading_scripts = [];
+Util._pending_scripts = [];
+Util.load_scripts = function (files) {
+    "use strict";
+    var head = document.getElementsByTagName('head')[0], script,
+        ls = Util._loading_scripts, ps = Util._pending_scripts;
+
+    var loadFunc = function (e) {
+        while (ls.length > 0 && (ls[0].readyState === 'loaded' ||
+                                 ls[0].readyState === 'complete')) {
+            // For IE, append the script to trigger execution
+            var s = ls.shift();
+            //console.log("loaded script: " + s.src);
+            head.appendChild(s);
+        }
+        if (!this.readyState ||
+            (Util.Engine.presto && this.readyState === 'loaded') ||
+            this.readyState === 'complete') {
+            if (ps.indexOf(this) >= 0) {
+                this.onload = this.onreadystatechange = null;
+                //console.log("completed script: " + this.src);
+                ps.splice(ps.indexOf(this), 1);
+
+                // Call window.onscriptsload after last script loads
+                if (ps.length === 0 && window.onscriptsload) {
+                    window.onscriptsload();
+                }
+            }
+        }
+    };
+
+    for (var f = 0; f < files.length; f++) {
+        script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.src = Util.get_include_uri() + files[f];
+        //console.log("loading script: " + script.src);
+        script.onload = script.onreadystatechange = loadFunc;
+        // In-order script execution tricks
+        if (Util.Engine.trident) {
+            // For IE wait until readyState is 'loaded' before
+            // appending it which will trigger execution
+            // http://wiki.whatwg.org/wiki/Dynamic_Script_Execution_Order
+            ls.push(script);
+        } else {
+            // For webkit and firefox set async=false and append now
+            // https://developer.mozilla.org/en-US/docs/HTML/Element/script
+            script.async = false;
+            head.appendChild(script);
+        }
+        ps.push(script);
+    }
+};
+
+
+Util.getPosition = function(obj) {
+    "use strict";
+    // NB(sross): the Mozilla developer reference seems to indicate that
+    // getBoundingClientRect includes border and padding, so the canvas
+    // style should NOT include either.
+    var objPosition = obj.getBoundingClientRect();
+    return {'x': objPosition.left + window.pageXOffset, 'y': objPosition.top + window.pageYOffset,
+            'width': objPosition.width, 'height': objPosition.height};
+};
+
+
+// Get mouse event position in DOM element
+Util.getEventPosition = function (e, obj, scale) {
+    "use strict";
+    var evt, docX, docY, pos;
+    //if (!e) evt = window.event;
+    evt = (e ? e : window.event);
+    evt = (evt.changedTouches ? evt.changedTouches[0] : evt.touches ? evt.touches[0] : evt);
+    if (evt.pageX || evt.pageY) {
+        docX = evt.pageX;
+        docY = evt.pageY;
+    } else if (evt.clientX || evt.clientY) {
+        docX = evt.clientX + document.body.scrollLeft +
+            document.documentElement.scrollLeft;
+        docY = evt.clientY + document.body.scrollTop +
+            document.documentElement.scrollTop;
+    }
+    pos = Util.getPosition(obj);
+    if (typeof scale === "undefined") {
+        scale = 1;
+    }
+    var realx = docX - pos.x;
+    var realy = docY - pos.y;
+    var x = Math.max(Math.min(realx, pos.width - 1), 0);
+    var y = Math.max(Math.min(realy, pos.height - 1), 0);
+    return {'x': x / scale, 'y': y / scale, 'realx': realx / scale, 'realy': realy / scale};
+};
+
+
+// Event registration. Based on: http://www.scottandrew.com/weblog/articles/cbs-events
+Util.addEvent = function (obj, evType, fn) {
+    "use strict";
+    if (obj.attachEvent) {
+        var r = obj.attachEvent("on" + evType, fn);
+        return r;
+    } else if (obj.addEventListener) {
+        obj.addEventListener(evType, fn, false);
+        return true;
+    } else {
+        throw new Error("Handler could not be attached");
+    }
+};
+
+Util.removeEvent = function (obj, evType, fn) {
+    "use strict";
+    if (obj.detachEvent) {
+        var r = obj.detachEvent("on" + evType, fn);
+        return r;
+    } else if (obj.removeEventListener) {
+        obj.removeEventListener(evType, fn, false);
+        return true;
+    } else {
+        throw new Error("Handler could not be removed");
+    }
+};
+
+Util.stopEvent = function (e) {
+    "use strict";
+    if (e.stopPropagation) { e.stopPropagation(); }
+    else                   { e.cancelBubble = true; }
+
+    if (e.preventDefault)  { e.preventDefault(); }
+    else                   { e.returnValue = false; }
+};
+
+Util._cursor_uris_supported = null;
+
+Util.browserSupportsCursorURIs = function () {
+    if (Util._cursor_uris_supported === null) {
+        try {
+            var target = document.createElement('canvas');
+            target.style.cursor = 'url("data:image/x-icon;base64,AAACAAEACAgAAAIAAgA4AQAAFgAAACgAAAAIAAAAEAAAAAEAIAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAD/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAAAA==") 2 2, default';
+
+            if (target.style.cursor) {
+                Util.Info("Data URI scheme cursor supported");
+                Util._cursor_uris_supported = true;
+            } else {
+                Util.Warn("Data URI scheme cursor not supported");
+                Util._cursor_uris_supported = false;
+            }
+        } catch (exc) {
+            Util.Error("Data URI scheme cursor test exception: " + exc);
+            Util._cursor_uris_supported = false;
+        }
+    }
+
+    return Util._cursor_uris_supported;
+};
+
+// Set browser engine versions. Based on mootools.
+Util.Features = {xpath: !!(document.evaluate), air: !!(window.runtime), query: !!(document.querySelector)};
+
+(function () {
+    "use strict";
+    // 'presto': (function () { return (!window.opera) ? false : true; }()),
+    var detectPresto = function () {
+        return !!window.opera;
+    };
+
+    // 'trident': (function () { return (!window.ActiveXObject) ? false : ((window.XMLHttpRequest) ? ((document.querySelectorAll) ? 6 : 5) : 4);
+    var detectTrident = function () {
+        if (!window.ActiveXObject) {
+            return false;
+        } else {
+            if (window.XMLHttpRequest) {
+                return (document.querySelectorAll) ? 6 : 5;
+            } else {
+                return 4;
+            }
+        }
+    };
+
+    // 'webkit': (function () { try { return (navigator.taintEnabled) ? false : ((Util.Features.xpath) ? ((Util.Features.query) ? 525 : 420) : 419); } catch (e) { return false; } }()),
+    var detectInitialWebkit = function () {
+        try {
+            if (navigator.taintEnabled) {
+                return false;
+            } else {
+                if (Util.Features.xpath) {
+                    return (Util.Features.query) ? 525 : 420;
+                } else {
+                    return 419;
+                }
+            }
+        } catch (e) {
+            return false;
+        }
+    };
+
+    var detectActualWebkit = function (initial_ver) {
+        var re = /WebKit\/([0-9\.]*) /;
+        var str_ver = (navigator.userAgent.match(re) || ['', initial_ver])[1];
+        return parseFloat(str_ver, 10);
+    };
+
+    // 'gecko': (function () { return (!document.getBoxObjectFor && window.mozInnerScreenX == null) ? false : ((document.getElementsByClassName) ? 19ssName) ? 19 : 18 : 18); }())
+    var detectGecko = function () {
+        /* jshint -W041 */
+        if (!document.getBoxObjectFor && window.mozInnerScreenX == null) {
+            return false;
+        } else {
+            return (document.getElementsByClassName) ? 19 : 18;
+        }
+        /* jshint +W041 */
+    };
+
+    Util.Engine = {
+        // Version detection break in Opera 11.60 (errors on arguments.callee.caller reference)
+        //'presto': (function() {
+        //         return (!window.opera) ? false : ((arguments.callee.caller) ? 960 : ((document.getElementsByClassName) ? 950 : 925)); }()),
+        'presto': detectPresto(),
+        'trident': detectTrident(),
+        'webkit': detectInitialWebkit(),
+        'gecko': detectGecko(),
+    };
+
+    if (Util.Engine.webkit) {
+        // Extract actual webkit version if available
+        Util.Engine.webkit = detectActualWebkit(Util.Engine.webkit);
+    }
+})();
+
+Util.Flash = (function () {
+    "use strict";
+    var v, version;
+    try {
+        v = navigator.plugins['Shockwave Flash'].description;
+    } catch (err1) {
+        try {
+            v = new ActiveXObject('ShockwaveFlash.ShockwaveFlash').GetVariable('$version');
+        } catch (err2) {
+            v = '0 r0';
+        }
+    }
+    version = v.match(/\d+/g);
+    return {version: parseInt(version[0] || 0 + '.' + version[1], 10) || 0, build: parseInt(version[2], 10) || 0};
+}());

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/web-socket-js/README.txt

@@ -0,0 +1,109 @@
+* How to try
+
+Assuming you have Web server (e.g. Apache) running at http://example.com/ .
+
+- Download web_socket.rb from:
+  http://github.com/gimite/web-socket-ruby/tree/master
+- Run sample Web Socket server (echo server) in example.com with: (#1)
+  $ ruby web-socket-ruby/samples/echo_server.rb example.com 10081
+- If your server already provides socket policy file at port 843, modify the file to allow access to port 10081. Otherwise you can skip this step. See below for details.
+- Publish the web-socket-js directory with your Web server (e.g. put it in ~/public_html).
+- Change ws://localhost:10081 to ws://example.com:10081 in sample.html.
+- Open sample.html in your browser.
+- After "onopen" is shown, input something, click [Send] and confirm echo back.
+
+#1: First argument of echo_server.rb means that it accepts Web Socket connection from HTML pages in example.com.
+
+
+* Troubleshooting
+
+If it doesn't work, try these:
+
+1. Try Chrome and Firefox 3.x.
+- It doesn't work on Chrome:
+-- It's likely an issue of your code or the server. Debug your code as usual e.g. using console.log.
+- It works on Chrome but it doesn't work on Firefox:
+-- It's likely an issue of web-socket-js specific configuration (e.g. 3 and 4 below).
+- It works on both Chrome and Firefox, but it doesn't work on your browser:
+-- Check "Supported environment" section below. Your browser may not be supported by web-socket-js.
+
+2. Add this line before your code:
+  WEB_SOCKET_DEBUG = true;
+and use Developer Tools (Chrome/Safari) or Firebug (Firefox) to see if console.log outputs any errors.
+
+3. Make sure you do NOT open your HTML page as local file e.g. file:///.../sample.html. web-socket-js doesn't work on local file. Open it via Web server e.g. http:///.../sample.html.
+
+4. If you are NOT using web-socket-ruby as your WebSocket server, you need to place Flash socket policy file on your server. See "Flash socket policy file" section below for details.
+
+5. Check if sample.html bundled with web-socket-js works.
+
+6. Make sure the port used for WebSocket (10081 in example above) is not blocked by your server/client's firewall.
+
+7. Install debugger version of Flash Player available here to see Flash errors:
+http://www.adobe.com/support/flashplayer/downloads.html
+
+
+* Supported environments
+
+It should work on:
+- Google Chrome 4 or later (just uses native implementation)
+- Firefox 3.x, Internet Explorer 8 + Flash Player 9 or later
+
+It may or may not work on other browsers such as Safari, Opera or IE 6. Patch for these browsers are appreciated, but I will not work on fixing issues specific to these browsers by myself.
+
+
+* Flash socket policy file
+
+This implementation uses Flash's socket, which means that your server must provide Flash socket policy file to declare the server accepts connections from Flash.
+
+If you use web-socket-ruby available at
+http://github.com/gimite/web-socket-ruby/tree/master
+, you don't need anything special, because web-socket-ruby handles Flash socket policy file request. But if you already provide socket policy file at port 843, you need to modify the file to allow access to Web Socket port, because it precedes what web-socket-ruby provides.
+
+If you use other Web Socket server implementation, you need to provide socket policy file yourself. See
+http://www.lightsphere.com/dev/articles/flash_socket_policy.html
+for details and sample script to run socket policy file server. node.js implementation is available here:
+http://github.com/LearnBoost/Socket.IO-node/blob/master/lib/socket.io/transports/flashsocket.js
+
+Actually, it's still better to provide socket policy file at port 843 even if you use web-socket-ruby. Flash always try to connect to port 843 first, so providing the file at port 843 makes startup faster.
+
+
+* Cookie considerations
+
+Cookie is sent if Web Socket host is the same as the origin of JavaScript. Otherwise it is not sent, because I don't know way to send right Cookie (which is Cookie of the host of Web Socket, I heard).
+
+Note that it's technically possible that client sends arbitrary string as Cookie and any other headers (by modifying this library for example) once you place Flash socket policy file in your server. So don't trust Cookie and other headers if you allow connection from untrusted origin.
+
+
+* Proxy considerations
+
+The WebSocket spec (http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol) specifies instructions for User Agents to support proxied connections by implementing the HTTP CONNECT method.
+
+The AS3 Socket class doesn't implement this mechanism, which renders it useless for the scenarios where the user trying to open a socket is behind a proxy. 
+
+The class RFC2817Socket (by Christian Cantrell) effectively lets us implement this, as long as the proxy settings are known and provided by the interface that instantiates the WebSocket. As such, if you want to support proxied conncetions, you'll have to supply this information to the WebSocket constructor when Flash is being used. One way to go about it would be to ask the user for proxy settings information if the initial connection fails.
+
+
+* How to host HTML file and SWF file in different domains
+
+By default, HTML file and SWF file must be in the same domain. You can follow steps below to allow hosting them in different domain.
+
+WARNING: If you use the method below, HTML files in ANY domains can send arbitrary TCP data to your WebSocket server, regardless of configuration in Flash socket policy file. Arbitrary TCP data means that they can even fake request headers including Origin and Cookie.
+
+- Unzip WebSocketMainInsecure.zip to extract WebSocketMainInsecure.swf.
+- Put WebSocketMainInsecure.swf on your server, instead of WebSocketMain.swf.
+- In JavaScript, set WEB_SOCKET_SWF_LOCATION to URL of your WebSocketMainInsecure.swf.
+
+
+* How to build WebSocketMain.swf
+
+Install Flex 4 SDK:
+http://opensource.adobe.com/wiki/display/flexsdk/Download+Flex+4
+
+$ cd flash-src
+$ ./build.sh
+
+
+* License
+
+New BSD License.

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/web-socket-js/web_socket.js

@@ -0,0 +1,391 @@
+// Copyright: Hiroshi Ichikawa <http://gimite.net/en/>
+// License: New BSD License
+// Reference: http://dev.w3.org/html5/websockets/
+// Reference: http://tools.ietf.org/html/rfc6455
+
+(function() {
+  
+  if (window.WEB_SOCKET_FORCE_FLASH) {
+    // Keeps going.
+  } else if (window.WebSocket) {
+    return;
+  } else if (window.MozWebSocket) {
+    // Firefox.
+    window.WebSocket = MozWebSocket;
+    return;
+  }
+  
+  var logger;
+  if (window.WEB_SOCKET_LOGGER) {
+    logger = WEB_SOCKET_LOGGER;
+  } else if (window.console && window.console.log && window.console.error) {
+    // In some environment, console is defined but console.log or console.error is missing.
+    logger = window.console;
+  } else {
+    logger = {log: function(){ }, error: function(){ }};
+  }
+  
+  // swfobject.hasFlashPlayerVersion("10.0.0") doesn't work with Gnash.
+  if (swfobject.getFlashPlayerVersion().major < 10) {
+    logger.error("Flash Player >= 10.0.0 is required.");
+    return;
+  }
+  if (location.protocol == "file:") {
+    logger.error(
+      "WARNING: web-socket-js doesn't work in file:///... URL " +
+      "unless you set Flash Security Settings properly. " +
+      "Open the page via Web server i.e. http://...");
+  }
+
+  /**
+   * Our own implementation of WebSocket class using Flash.
+   * @param {string} url
+   * @param {array or string} protocols
+   * @param {string} proxyHost
+   * @param {int} proxyPort
+   * @param {string} headers
+   */
+  window.WebSocket = function(url, protocols, proxyHost, proxyPort, headers) {
+    var self = this;
+    self.__id = WebSocket.__nextId++;
+    WebSocket.__instances[self.__id] = self;
+    self.readyState = WebSocket.CONNECTING;
+    self.bufferedAmount = 0;
+    self.__events = {};
+    if (!protocols) {
+      protocols = [];
+    } else if (typeof protocols == "string") {
+      protocols = [protocols];
+    }
+    // Uses setTimeout() to make sure __createFlash() runs after the caller sets ws.onopen etc.
+    // Otherwise, when onopen fires immediately, onopen is called before it is set.
+    self.__createTask = setTimeout(function() {
+      WebSocket.__addTask(function() {
+        self.__createTask = null;
+        WebSocket.__flash.create(
+            self.__id, url, protocols, proxyHost || null, proxyPort || 0, headers || null);
+      });
+    }, 0);
+  };
+
+  /**
+   * Send data to the web socket.
+   * @param {string} data  The data to send to the socket.
+   * @return {boolean}  True for success, false for failure.
+   */
+  WebSocket.prototype.send = function(data) {
+    if (this.readyState == WebSocket.CONNECTING) {
+      throw "INVALID_STATE_ERR: Web Socket connection has not been established";
+    }
+    // We use encodeURIComponent() here, because FABridge doesn't work if
+    // the argument includes some characters. We don't use escape() here
+    // because of this:
+    // https://developer.mozilla.org/en/Core_JavaScript_1.5_Guide/Functions#escape_and_unescape_Functions
+    // But it looks decodeURIComponent(encodeURIComponent(s)) doesn't
+    // preserve all Unicode characters either e.g. "\uffff" in Firefox.
+    // Note by wtritch: Hopefully this will not be necessary using ExternalInterface.  Will require
+    // additional testing.
+    var result = WebSocket.__flash.send(this.__id, encodeURIComponent(data));
+    if (result < 0) { // success
+      return true;
+    } else {
+      this.bufferedAmount += result;
+      return false;
+    }
+  };
+
+  /**
+   * Close this web socket gracefully.
+   */
+  WebSocket.prototype.close = function() {
+    if (this.__createTask) {
+      clearTimeout(this.__createTask);
+      this.__createTask = null;
+      this.readyState = WebSocket.CLOSED;
+      return;
+    }
+    if (this.readyState == WebSocket.CLOSED || this.readyState == WebSocket.CLOSING) {
+      return;
+    }
+    this.readyState = WebSocket.CLOSING;
+    WebSocket.__flash.close(this.__id);
+  };
+
+  /**
+   * Implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-registration">DOM 2 EventTarget Interface</a>}
+   *
+   * @param {string} type
+   * @param {function} listener
+   * @param {boolean} useCapture
+   * @return void
+   */
+  WebSocket.prototype.addEventListener = function(type, listener, useCapture) {
+    if (!(type in this.__events)) {
+      this.__events[type] = [];
+    }
+    this.__events[type].push(listener);
+  };
+
+  /**
+   * Implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-registration">DOM 2 EventTarget Interface</a>}
+   *
+   * @param {string} type
+   * @param {function} listener
+   * @param {boolean} useCapture
+   * @return void
+   */
+  WebSocket.prototype.removeEventListener = function(type, listener, useCapture) {
+    if (!(type in this.__events)) return;
+    var events = this.__events[type];
+    for (var i = events.length - 1; i >= 0; --i) {
+      if (events[i] === listener) {
+        events.splice(i, 1);
+        break;
+      }
+    }
+  };
+
+  /**
+   * Implementation of {@link <a href="http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-registration">DOM 2 EventTarget Interface</a>}
+   *
+   * @param {Event} event
+   * @return void
+   */
+  WebSocket.prototype.dispatchEvent = function(event) {
+    var events = this.__events[event.type] || [];
+    for (var i = 0; i < events.length; ++i) {
+      events[i](event);
+    }
+    var handler = this["on" + event.type];
+    if (handler) handler.apply(this, [event]);
+  };
+
+  /**
+   * Handles an event from Flash.
+   * @param {Object} flashEvent
+   */
+  WebSocket.prototype.__handleEvent = function(flashEvent) {
+    
+    if ("readyState" in flashEvent) {
+      this.readyState = flashEvent.readyState;
+    }
+    if ("protocol" in flashEvent) {
+      this.protocol = flashEvent.protocol;
+    }
+    
+    var jsEvent;
+    if (flashEvent.type == "open" || flashEvent.type == "error") {
+      jsEvent = this.__createSimpleEvent(flashEvent.type);
+    } else if (flashEvent.type == "close") {
+      jsEvent = this.__createSimpleEvent("close");
+      jsEvent.wasClean = flashEvent.wasClean ? true : false;
+      jsEvent.code = flashEvent.code;
+      jsEvent.reason = flashEvent.reason;
+    } else if (flashEvent.type == "message") {
+      var data = decodeURIComponent(flashEvent.message);
+      jsEvent = this.__createMessageEvent("message", data);
+    } else {
+      throw "unknown event type: " + flashEvent.type;
+    }
+    
+    this.dispatchEvent(jsEvent);
+    
+  };
+  
+  WebSocket.prototype.__createSimpleEvent = function(type) {
+    if (document.createEvent && window.Event) {
+      var event = document.createEvent("Event");
+      event.initEvent(type, false, false);
+      return event;
+    } else {
+      return {type: type, bubbles: false, cancelable: false};
+    }
+  };
+  
+  WebSocket.prototype.__createMessageEvent = function(type, data) {
+    if (document.createEvent && window.MessageEvent && !window.opera) {
+      var event = document.createEvent("MessageEvent");
+      event.initMessageEvent("message", false, false, data, null, null, window, null);
+      return event;
+    } else {
+      // IE and Opera, the latter one truncates the data parameter after any 0x00 bytes.
+      return {type: type, data: data, bubbles: false, cancelable: false};
+    }
+  };
+  
+  /**
+   * Define the WebSocket readyState enumeration.
+   */
+  WebSocket.CONNECTING = 0;
+  WebSocket.OPEN = 1;
+  WebSocket.CLOSING = 2;
+  WebSocket.CLOSED = 3;
+
+  // Field to check implementation of WebSocket.
+  WebSocket.__isFlashImplementation = true;
+  WebSocket.__initialized = false;
+  WebSocket.__flash = null;
+  WebSocket.__instances = {};
+  WebSocket.__tasks = [];
+  WebSocket.__nextId = 0;
+  
+  /**
+   * Load a new flash security policy file.
+   * @param {string} url
+   */
+  WebSocket.loadFlashPolicyFile = function(url){
+    WebSocket.__addTask(function() {
+      WebSocket.__flash.loadManualPolicyFile(url);
+    });
+  };
+
+  /**
+   * Loads WebSocketMain.swf and creates WebSocketMain object in Flash.
+   */
+  WebSocket.__initialize = function() {
+    
+    if (WebSocket.__initialized) return;
+    WebSocket.__initialized = true;
+    
+    if (WebSocket.__swfLocation) {
+      // For backword compatibility.
+      window.WEB_SOCKET_SWF_LOCATION = WebSocket.__swfLocation;
+    }
+    if (!window.WEB_SOCKET_SWF_LOCATION) {
+      logger.error("[WebSocket] set WEB_SOCKET_SWF_LOCATION to location of WebSocketMain.swf");
+      return;
+    }
+    if (!window.WEB_SOCKET_SUPPRESS_CROSS_DOMAIN_SWF_ERROR &&
+        !WEB_SOCKET_SWF_LOCATION.match(/(^|\/)WebSocketMainInsecure\.swf(\?.*)?$/) &&
+        WEB_SOCKET_SWF_LOCATION.match(/^\w+:\/\/([^\/]+)/)) {
+      var swfHost = RegExp.$1;
+      if (location.host != swfHost) {
+        logger.error(
+            "[WebSocket] You must host HTML and WebSocketMain.swf in the same host " +
+            "('" + location.host + "' != '" + swfHost + "'). " +
+            "See also 'How to host HTML file and SWF file in different domains' section " +
+            "in README.md. If you use WebSocketMainInsecure.swf, you can suppress this message " +
+            "by WEB_SOCKET_SUPPRESS_CROSS_DOMAIN_SWF_ERROR = true;");
+      }
+    }
+    var container = document.createElement("div");
+    container.id = "webSocketContainer";
+    // Hides Flash box. We cannot use display: none or visibility: hidden because it prevents
+    // Flash from loading at least in IE. So we move it out of the screen at (-100, -100).
+    // But this even doesn't work with Flash Lite (e.g. in Droid Incredible). So with Flash
+    // Lite, we put it at (0, 0). This shows 1x1 box visible at left-top corner but this is
+    // the best we can do as far as we know now.
+    container.style.position = "absolute";
+    if (WebSocket.__isFlashLite()) {
+      container.style.left = "0px";
+      container.style.top = "0px";
+    } else {
+      container.style.left = "-100px";
+      container.style.top = "-100px";
+    }
+    var holder = document.createElement("div");
+    holder.id = "webSocketFlash";
+    container.appendChild(holder);
+    document.body.appendChild(container);
+    // See this article for hasPriority:
+    // http://help.adobe.com/en_US/as3/mobile/WS4bebcd66a74275c36cfb8137124318eebc6-7ffd.html
+    swfobject.embedSWF(
+      WEB_SOCKET_SWF_LOCATION,
+      "webSocketFlash",
+      "1" /* width */,
+      "1" /* height */,
+      "10.0.0" /* SWF version */,
+      null,
+      null,
+      {hasPriority: true, swliveconnect : true, allowScriptAccess: "always"},
+      null,
+      function(e) {
+        if (!e.success) {
+          logger.error("[WebSocket] swfobject.embedSWF failed");
+        }
+      }
+    );
+    
+  };
+  
+  /**
+   * Called by Flash to notify JS that it's fully loaded and ready
+   * for communication.
+   */
+  WebSocket.__onFlashInitialized = function() {
+    // We need to set a timeout here to avoid round-trip calls
+    // to flash during the initialization process.
+    setTimeout(function() {
+      WebSocket.__flash = document.getElementById("webSocketFlash");
+      WebSocket.__flash.setCallerUrl(location.href);
+      WebSocket.__flash.setDebug(!!window.WEB_SOCKET_DEBUG);
+      for (var i = 0; i < WebSocket.__tasks.length; ++i) {
+        WebSocket.__tasks[i]();
+      }
+      WebSocket.__tasks = [];
+    }, 0);
+  };
+  
+  /**
+   * Called by Flash to notify WebSockets events are fired.
+   */
+  WebSocket.__onFlashEvent = function() {
+    setTimeout(function() {
+      try {
+        // Gets events using receiveEvents() instead of getting it from event object
+        // of Flash event. This is to make sure to keep message order.
+        // It seems sometimes Flash events don't arrive in the same order as they are sent.
+        var events = WebSocket.__flash.receiveEvents();
+        for (var i = 0; i < events.length; ++i) {
+          WebSocket.__instances[events[i].webSocketId].__handleEvent(events[i]);
+        }
+      } catch (e) {
+        logger.error(e);
+      }
+    }, 0);
+    return true;
+  };
+  
+  // Called by Flash.
+  WebSocket.__log = function(message) {
+    logger.log(decodeURIComponent(message));
+  };
+  
+  // Called by Flash.
+  WebSocket.__error = function(message) {
+    logger.error(decodeURIComponent(message));
+  };
+  
+  WebSocket.__addTask = function(task) {
+    if (WebSocket.__flash) {
+      task();
+    } else {
+      WebSocket.__tasks.push(task);
+    }
+  };
+  
+  /**
+   * Test if the browser is running flash lite.
+   * @return {boolean} True if flash lite is running, false otherwise.
+   */
+  WebSocket.__isFlashLite = function() {
+    if (!window.navigator || !window.navigator.mimeTypes) {
+      return false;
+    }
+    var mimeType = window.navigator.mimeTypes["application/x-shockwave-flash"];
+    if (!mimeType || !mimeType.enabledPlugin || !mimeType.enabledPlugin.filename) {
+      return false;
+    }
+    return mimeType.enabledPlugin.filename.match(/flashlite/i) ? true : false;
+  };
+  
+  if (!window.WEB_SOCKET_DISABLE_AUTO_INITIALIZATION) {
+    // NOTE:
+    //   This fires immediately if web_socket.js is dynamically loaded after
+    //   the document is loaded.
+    swfobject.addDomLoadEvent(function() {
+      WebSocket.__initialize();
+    });
+  }
+  
+})();

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/websock.js

@@ -0,0 +1,388 @@
+/*
+ * Websock: high-performance binary WebSockets
+ * Copyright (C) 2012 Joel Martin
+ * Licensed under MPL 2.0 (see LICENSE.txt)
+ *
+ * Websock is similar to the standard WebSocket object but Websock
+ * enables communication with raw TCP sockets (i.e. the binary stream)
+ * via websockify. This is accomplished by base64 encoding the data
+ * stream between Websock and websockify.
+ *
+ * Websock has built-in receive queue buffering; the message event
+ * does not contain actual data but is simply a notification that
+ * there is new data available. Several rQ* methods are available to
+ * read binary data off of the receive queue.
+ */
+
+/*jslint browser: true, bitwise: true */
+/*global Util, Base64 */
+
+
+// Load Flash WebSocket emulator if needed
+
+// To force WebSocket emulator even when native WebSocket available
+//window.WEB_SOCKET_FORCE_FLASH = true;
+// To enable WebSocket emulator debug:
+//window.WEB_SOCKET_DEBUG=1;
+
+if (window.WebSocket && !window.WEB_SOCKET_FORCE_FLASH) {
+    Websock_native = true;
+} else if (window.MozWebSocket && !window.WEB_SOCKET_FORCE_FLASH) {
+    Websock_native = true;
+    window.WebSocket = window.MozWebSocket;
+} else {
+    /* no builtin WebSocket so load web_socket.js */
+
+    Websock_native = false;
+    (function () {
+        window.WEB_SOCKET_SWF_LOCATION = Util.get_include_uri() +
+                    "web-socket-js/WebSocketMain.swf";
+        if (Util.Engine.trident) {
+            Util.Debug("Forcing uncached load of WebSocketMain.swf");
+            window.WEB_SOCKET_SWF_LOCATION += "?" + Math.random();
+        }
+        Util.load_scripts(["web-socket-js/swfobject.js",
+                           "web-socket-js/web_socket.js"]);
+    })();
+}
+
+
+function Websock() {
+    "use strict";
+
+    this._websocket = null;  // WebSocket object
+    this._rQ = [];           // Receive queue
+    this._rQi = 0;           // Receive queue index
+    this._rQmax = 10000;     // Max receive queue size before compacting
+    this._sQ = [];           // Send queue
+
+    this._mode = 'base64';    // Current WebSocket mode: 'binary', 'base64'
+    this.maxBufferedAmount = 200;
+
+    this._eventHandlers = {
+        'message': function () {},
+        'open': function () {},
+        'close': function () {},
+        'error': function () {}
+    };
+}
+
+(function () {
+    "use strict";
+    Websock.prototype = {
+        // Getters and Setters
+        get_sQ: function () {
+            return this._sQ;
+        },
+
+        get_rQ: function () {
+            return this._rQ;
+        },
+
+        get_rQi: function () {
+            return this._rQi;
+        },
+
+        set_rQi: function (val) {
+            this._rQi = val;
+        },
+
+        // Receive Queue
+        rQlen: function () {
+            return this._rQ.length - this._rQi;
+        },
+
+        rQpeek8: function () {
+            return this._rQ[this._rQi];
+        },
+
+        rQshift8: function () {
+            return this._rQ[this._rQi++];
+        },
+
+        rQskip8: function () {
+            this._rQi++;
+        },
+
+        rQskipBytes: function (num) {
+            this._rQi += num;
+        },
+
+        rQunshift8: function (num) {
+            if (this._rQi === 0) {
+                this._rQ.unshift(num);
+            } else {
+                this._rQi--;
+                this._rQ[this._rQi] = num;
+            }
+        },
+
+        rQshift16: function () {
+            return (this._rQ[this._rQi++] << 8) +
+                   this._rQ[this._rQi++];
+        },
+
+        rQshift32: function () {
+            return (this._rQ[this._rQi++] << 24) +
+                   (this._rQ[this._rQi++] << 16) +
+                   (this._rQ[this._rQi++] << 8) +
+                   this._rQ[this._rQi++];
+        },
+
+        rQshiftStr: function (len) {
+            if (typeof(len) === 'undefined') { len = this.rQlen(); }
+            var arr = this._rQ.slice(this._rQi, this._rQi + len);
+            this._rQi += len;
+            return String.fromCharCode.apply(null, arr);
+        },
+
+        rQshiftBytes: function (len) {
+            if (typeof(len) === 'undefined') { len = this.rQlen(); }
+            this._rQi += len;
+            return this._rQ.slice(this._rQi - len, this._rQi);
+        },
+
+        rQslice: function (start, end) {
+            if (end) {
+                return this._rQ.slice(this._rQi + start, this._rQi + end);
+            } else {
+                return this._rQ.slice(this._rQi + start);
+            }
+        },
+
+        // Check to see if we must wait for 'num' bytes (default to FBU.bytes)
+        // to be available in the receive queue. Return true if we need to
+        // wait (and possibly print a debug message), otherwise false.
+        rQwait: function (msg, num, goback) {
+            var rQlen = this._rQ.length - this._rQi; // Skip rQlen() function call
+            if (rQlen < num) {
+                if (goback) {
+                    if (this._rQi < goback) {
+                        throw new Error("rQwait cannot backup " + goback + " bytes");
+                    }
+                    this._rQi -= goback;
+                }
+                return true; // true means need more data
+            }
+            return false;
+        },
+
+        // Send Queue
+
+        flush: function () {
+            if (this._websocket.bufferedAmount !== 0) {
+                Util.Debug("bufferedAmount: " + this._websocket.bufferedAmount);
+            }
+
+            if (this._websocket.bufferedAmount < this.maxBufferedAmount) {
+                if (this._sQ.length > 0) {
+                    this._websocket.send(this._encode_message());
+                    this._sQ = [];
+                }
+
+                return true;
+            } else {
+                Util.Info("Delaying send, bufferedAmount: " +
+                        this._websocket.bufferedAmount);
+                return false;
+            }
+        },
+
+        send: function (arr) {
+           this._sQ = this._sQ.concat(arr);
+           return this.flush();
+        },
+
+        send_string: function (str) {
+            this.send(str.split('').map(function (chr) {
+                return chr.charCodeAt(0);
+            }));
+        },
+
+        // Event Handlers
+        off: function (evt) {
+            this._eventHandlers[evt] = function () {};
+        },
+
+        on: function (evt, handler) {
+            this._eventHandlers[evt] = handler;
+        },
+
+        init: function (protocols, ws_schema) {
+            this._rQ = [];
+            this._rQi = 0;
+            this._sQ = [];
+            this._websocket = null;
+
+            // Check for full typed array support
+            var bt = false;
+            if (('Uint8Array' in window) &&
+                    ('set' in Uint8Array.prototype)) {
+                bt = true;
+            }
+
+            // Check for full binary type support in WebSockets
+            // Inspired by:
+            // https://github.com/Modernizr/Modernizr/issues/370
+            // https://github.com/Modernizr/Modernizr/blob/master/feature-detects/websockets/binary.js
+            var wsbt = false;
+            try {
+                if (bt && ('binaryType' in WebSocket.prototype ||
+                           !!(new WebSocket(ws_schema + '://.').binaryType))) {
+                    Util.Info("Detected binaryType support in WebSockets");
+                    wsbt = true;
+                }
+            } catch (exc) {
+                // Just ignore failed test localhost connection
+            }
+
+            // Default protocols if not specified
+            if (typeof(protocols) === "undefined") {
+                if (wsbt) {
+                    protocols = ['binary', 'base64'];
+                } else {
+                    protocols = 'base64';
+                }
+            }
+
+            if (!wsbt) {
+                if (protocols === 'binary') {
+                    throw new Error('WebSocket binary sub-protocol requested but not supported');
+                }
+
+                if (typeof(protocols) === 'object') {
+                    var new_protocols = [];
+
+                    for (var i = 0; i < protocols.length; i++) {
+                        if (protocols[i] === 'binary') {
+                            Util.Error('Skipping unsupported WebSocket binary sub-protocol');
+                        } else {
+                            new_protocols.push(protocols[i]);
+                        }
+                    }
+
+                    if (new_protocols.length > 0) {
+                        protocols = new_protocols;
+                    } else {
+                        throw new Error("Only WebSocket binary sub-protocol was requested and is not supported.");
+                    }
+                }
+            }
+
+            return protocols;
+        },
+
+        open: function (uri, protocols) {
+            var ws_schema = uri.match(/^([a-z]+):\/\//)[1];
+            protocols = this.init(protocols, ws_schema);
+
+            this._websocket = new WebSocket(uri, protocols);
+
+            if (protocols.indexOf('binary') >= 0) {
+                this._websocket.binaryType = 'arraybuffer';
+            }
+
+            this._websocket.onmessage = this._recv_message.bind(this);
+            this._websocket.onopen = (function () {
+                Util.Debug('>> WebSock.onopen');
+                if (this._websocket.protocol) {
+                    this._mode = this._websocket.protocol;
+                    Util.Info("Server choose sub-protocol: " + this._websocket.protocol);
+                } else {
+                    this._mode = 'base64';
+                    Util.Error('Server select no sub-protocol!: ' + this._websocket.protocol);
+                }
+                this._eventHandlers.open();
+                Util.Debug("<< WebSock.onopen");
+            }).bind(this);
+            this._websocket.onclose = (function (e) {
+                Util.Debug(">> WebSock.onclose");
+                this._eventHandlers.close(e);
+                Util.Debug("<< WebSock.onclose");
+            }).bind(this);
+            this._websocket.onerror = (function (e) {
+                Util.Debug(">> WebSock.onerror: " + e);
+                this._eventHandlers.error(e);
+                Util.Debug("<< WebSock.onerror: " + e);
+            }).bind(this);
+        },
+
+        close: function () {
+            if (this._websocket) {
+                if ((this._websocket.readyState === WebSocket.OPEN) ||
+                        (this._websocket.readyState === WebSocket.CONNECTING)) {
+                    Util.Info("Closing WebSocket connection");
+                    this._websocket.close();
+                }
+
+                this._websocket.onmessage = function (e) { return; };
+            }
+        },
+
+        // private methods
+        _encode_message: function () {
+            if (this._mode === 'binary') {
+                // Put in a binary arraybuffer
+                return (new Uint8Array(this._sQ)).buffer;
+            } else {
+                // base64 encode
+                return Base64.encode(this._sQ);
+            }
+        },
+
+        _decode_message: function (data) {
+            if (this._mode === 'binary') {
+                // push arraybuffer values onto the end
+                var u8 = new Uint8Array(data);
+                for (var i = 0; i < u8.length; i++) {
+                    this._rQ.push(u8[i]);
+                }
+            } else {
+                // base64 decode and concat to end
+                this._rQ = this._rQ.concat(Base64.decode(data, 0));
+            }
+        },
+
+        _recv_message: function (e) {
+            try {
+                this._decode_message(e.data);
+                if (this.rQlen() > 0) {
+                    this._eventHandlers.message();
+                    // Compact the receive queue
+                    if (this._rQ.length > this._rQmax) {
+                        this._rQ = this._rQ.slice(this._rQi);
+                        this._rQi = 0;
+                    }
+                } else {
+                    Util.Debug("Ignoring empty message");
+                }
+            } catch (exc) {
+                var exception_str = "";
+                if (exc.name) {
+                    exception_str += "\n    name: " + exc.name + "\n";
+                    exception_str += "    message: " + exc.message + "\n";
+                }
+
+                if (typeof exc.description !== 'undefined') {
+                    exception_str += "    description: " + exc.description + "\n";
+                }
+
+                if (typeof exc.stack !== 'undefined') {
+                    exception_str += exc.stack;
+                }
+
+                if (exception_str.length > 0) {
+                    Util.Error("recv_message, caught exception: " + exception_str);
+                } else {
+                    Util.Error("recv_message, caught exception: " + exc);
+                }
+
+                if (typeof exc.name !== 'undefined') {
+                    this._eventHandlers.error(exc.name + ": " + exc.message);
+                } else {
+                    this._eventHandlers.error(exc);
+                }
+            }
+        }
+    };
+})();

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/include/webutil.js

@@ -0,0 +1,239 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2012 Joel Martin
+ * Copyright (C) 2013 NTT corp.
+ * Licensed under MPL 2.0 (see LICENSE.txt)
+ *
+ * See README.md for usage and integration instructions.
+ */
+
+/*jslint bitwise: false, white: false, browser: true, devel: true */
+/*global Util, window, document */
+
+// Globals defined here
+var WebUtil = {}, $D;
+
+/*
+ * Simple DOM selector by ID
+ */
+if (!window.$D) {
+    window.$D = function (id) {
+        if (document.getElementById) {
+            return document.getElementById(id);
+        } else if (document.all) {
+            return document.all[id];
+        } else if (document.layers) {
+            return document.layers[id];
+        }
+        return undefined;
+    };
+}
+
+
+/*
+ * ------------------------------------------------------
+ * Namespaced in WebUtil
+ * ------------------------------------------------------
+ */
+
+// init log level reading the logging HTTP param
+WebUtil.init_logging = function (level) {
+    "use strict";
+    if (typeof level !== "undefined") {
+        Util._log_level = level;
+    } else {
+        var param = document.location.href.match(/logging=([A-Za-z0-9\._\-]*)/);
+        Util._log_level = (param || ['', Util._log_level])[1];
+    }
+    Util.init_logging();
+};
+
+
+WebUtil.dirObj = function (obj, depth, parent) {
+    "use strict";
+    if (! depth) { depth = 2; }
+    if (! parent) { parent = ""; }
+
+    // Print the properties of the passed-in object
+    var msg = "";
+    for (var i in obj) {
+        if ((depth > 1) && (typeof obj[i] === "object")) {
+            // Recurse attributes that are objects
+            msg += WebUtil.dirObj(obj[i], depth - 1, parent + "." + i);
+        } else {
+            //val = new String(obj[i]).replace("\n", " ");
+            var val = "";
+            if (typeof(obj[i]) === "undefined") {
+                val = "undefined";
+            } else {
+                val = obj[i].toString().replace("\n", " ");
+            }
+            if (val.length > 30) {
+                val = val.substr(0, 30) + "...";
+            }
+            msg += parent + "." + i + ": " + val + "\n";
+        }
+    }
+    return msg;
+};
+
+// Read a query string variable
+WebUtil.getQueryVar = function (name, defVal) {
+    "use strict";
+    var re = new RegExp('.*[?&]' + name + '=([^&#]*)'),
+        match = document.location.href.match(re);
+    if (typeof defVal === 'undefined') { defVal = null; }
+    if (match) {
+        return decodeURIComponent(match[1]);
+    } else {
+        return defVal;
+    }
+};
+
+
+/*
+ * Cookie handling. Dervied from: http://www.quirksmode.org/js/cookies.html
+ */
+
+// No days means only for this browser session
+WebUtil.createCookie = function (name, value, days) {
+    "use strict";
+    var date, expires;
+    if (days) {
+        date = new Date();
+        date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+        expires = "; expires=" + date.toGMTString();
+    } else {
+        expires = "";
+    }
+
+    var secure;
+    if (document.location.protocol === "https:") {
+        secure = "; secure";
+    } else {
+        secure = "";
+    }
+    document.cookie = name + "=" + value + expires + "; path=/" + secure;
+};
+
+WebUtil.readCookie = function (name, defaultValue) {
+    "use strict";
+    var nameEQ = name + "=",
+        ca = document.cookie.split(';');
+
+    for (var i = 0; i < ca.length; i += 1) {
+        var c = ca[i];
+        while (c.charAt(0) === ' ') { c = c.substring(1, c.length); }
+        if (c.indexOf(nameEQ) === 0) { return c.substring(nameEQ.length, c.length); }
+    }
+    return (typeof defaultValue !== 'undefined') ? defaultValue : null;
+};
+
+WebUtil.eraseCookie = function (name) {
+    "use strict";
+    WebUtil.createCookie(name, "", -1);
+};
+
+/*
+ * Setting handling.
+ */
+
+WebUtil.initSettings = function (callback /*, ...callbackArgs */) {
+    "use strict";
+    var callbackArgs = Array.prototype.slice.call(arguments, 1);
+    if (window.chrome && window.chrome.storage) {
+        window.chrome.storage.sync.get(function (cfg) {
+            WebUtil.settings = cfg;
+            console.log(WebUtil.settings);
+            if (callback) {
+                callback.apply(this, callbackArgs);
+            }
+        });
+    } else {
+        // No-op
+        if (callback) {
+            callback.apply(this, callbackArgs);
+        }
+    }
+};
+
+// No days means only for this browser session
+WebUtil.writeSetting = function (name, value) {
+    "use strict";
+    if (window.chrome && window.chrome.storage) {
+        //console.log("writeSetting:", name, value);
+        if (WebUtil.settings[name] !== value) {
+            WebUtil.settings[name] = value;
+            window.chrome.storage.sync.set(WebUtil.settings);
+        }
+    } else {
+        localStorage.setItem(name, value);
+    }
+};
+
+WebUtil.readSetting = function (name, defaultValue) {
+    "use strict";
+    var value;
+    if (window.chrome && window.chrome.storage) {
+        value = WebUtil.settings[name];
+    } else {
+        value = localStorage.getItem(name);
+    }
+    if (typeof value === "undefined") {
+        value = null;
+    }
+    if (value === null && typeof defaultValue !== undefined) {
+        return defaultValue;
+    } else {
+        return value;
+    }
+};
+
+WebUtil.eraseSetting = function (name) {
+    "use strict";
+    if (window.chrome && window.chrome.storage) {
+        window.chrome.storage.sync.remove(name);
+        delete WebUtil.settings[name];
+    } else {
+        localStorage.removeItem(name);
+    }
+};
+
+/*
+ * Alternate stylesheet selection
+ */
+WebUtil.getStylesheets = function () {
+    "use strict";
+    var links = document.getElementsByTagName("link");
+    var sheets = [];
+
+    for (var i = 0; i < links.length; i += 1) {
+        if (links[i].title &&
+            links[i].rel.toUpperCase().indexOf("STYLESHEET") > -1) {
+            sheets.push(links[i]);
+        }
+    }
+    return sheets;
+};
+
+// No sheet means try and use value from cookie, null sheet used to
+// clear all alternates.
+WebUtil.selectStylesheet = function (sheet) {
+    "use strict";
+    if (typeof sheet === 'undefined') {
+        sheet = 'default';
+    }
+
+    var sheets = WebUtil.getStylesheets();
+    for (var i = 0; i < sheets.length; i += 1) {
+        var link = sheets[i];
+        if (link.title === sheet) {
+            Util.Debug("Using stylesheet " + sheet);
+            link.disabled = false;
+        } else {
+            //Util.Debug("Skipping stylesheet " + link.title);
+            link.disabled = true;
+        }
+    }
+    return sheet;
+};

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/karma.conf.js

@@ -0,0 +1,197 @@
+// Karma configuration
+
+module.exports = function(config) {
+  /*var customLaunchers = {
+    sl_chrome_win7: {
+      base: 'SauceLabs',
+      browserName: 'chrome',
+      platform: 'Windows 7'
+    },
+
+    sl_firefox30_linux: {
+      base: 'SauceLabs',
+      browserName: 'firefox',
+      version: '30',
+      platform: 'Linux'
+    },
+
+    sl_firefox26_linux: {
+      base: 'SauceLabs',
+      browserName: 'firefox',
+      version: 26,
+      platform: 'Linux'
+    },
+
+    sl_windows7_ie10: {
+      base: 'SauceLabs',
+      browserName: 'internet explorer',
+      platform: 'Windows 7',
+      version: '10'
+    },
+
+    sl_windows81_ie11: {
+      base: 'SauceLabs',
+      browserName: 'internet explorer',
+      platform: 'Windows 8.1',
+      version: '11'
+    },
+
+    sl_osxmavericks_safari7: {
+      base: 'SauceLabs',
+      browserName: 'safari',
+      platform: 'OS X 10.9',
+      version: '7'
+    },
+
+    sl_osxmtnlion_safari6: {
+      base: 'SauceLabs',
+      browserName: 'safari',
+      platform: 'OS X 10.8',
+      version: '6'
+    }
+  };*/
+
+  var customLaunchers = {};
+  var browsers = [];
+  var useSauce = false;
+
+  if (process.env.SAUCE_USERNAME && process.env.SAUCE_ACCESS_KEY) {
+    useSauce = true;
+  }
+
+  if (useSauce && process.env.TEST_BROWSER_NAME && process.env.TEST_BROWSER_NAME != 'PhantomJS') {
+    var names = process.env.TEST_BROWSER_NAME.split(',');
+    var platforms = process.env.TEST_BROWSER_OS.split(',');
+    var versions = [];
+    if (process.env.TEST_BROWSER_VERSION) {
+      versions = process.env.TEST_BROWSER_VERSION.split(',');
+    } else {
+      versions = [null];
+    }
+
+    for (var i = 0; i < names.length; i++) {
+      for (var j = 0; j < platforms.length; j++) {
+        for (var k = 0; k < versions.length; k++) {
+          var launcher_name = 'sl_' + platforms[j].replace(/[^a-zA-Z0-9]/g, '') + '_' + names[i];
+          if (versions[k]) {
+            launcher_name += '_' + versions[k];
+          }
+
+          customLaunchers[launcher_name] = {
+            base: 'SauceLabs',
+            browserName: names[i],
+            platform: platforms[j],
+          };
+
+          if (versions[i]) {
+            customLaunchers[launcher_name].version = versions[k];
+          }
+        }
+      }
+    }
+
+    browsers = Object.keys(customLaunchers);
+  } else {
+    useSauce = false;
+    browsers = ['PhantomJS'];
+  }
+
+  var my_conf = {
+
+    // base path that will be used to resolve all patterns (eg. files, exclude)
+    basePath: '',
+
+    // frameworks to use
+    // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
+    frameworks: ['mocha', 'sinon', 'chai', 'sinon-chai'],
+
+
+    // list of files / patterns to load in the browser (loaded in order)
+    files: [
+      'tests/fake.*.js',
+      'tests/assertions.js',
+      'include/util.js',  // load first to avoid issues, since methods are called immediately
+      //'../include/*.js',
+      'include/base64.js',
+      'include/keysym.js',
+      'include/keysymdef.js',
+      'include/keyboard.js',
+      'include/input.js',
+      'include/websock.js',
+      'include/rfb.js',
+      'include/jsunzip.js',
+      'include/des.js',
+      'include/display.js',
+      'tests/test.*.js'
+    ],
+
+    client: {
+      mocha: {
+        'ui': 'bdd'
+      }
+    },
+
+    // list of files to exclude
+    exclude: [
+      '../include/playback.js',
+      '../include/ui.js'
+    ],
+
+    customLaunchers: customLaunchers,
+
+    // start these browsers
+    // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
+    browsers: browsers,
+
+    // preprocess matching files before serving them to the browser
+    // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
+    preprocessors: {
+
+    },
+
+
+    // test results reporter to use
+    // possible values: 'dots', 'progress'
+    // available reporters: https://npmjs.org/browse/keyword/karma-reporter
+    reporters: ['mocha', 'saucelabs'],
+
+
+    // web server port
+    port: 9876,
+
+
+    // enable / disable colors in the output (reporters and logs)
+    colors: true,
+
+
+    // level of logging
+    // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
+    logLevel: config.LOG_INFO,
+
+
+    // enable / disable watching file and executing tests whenever any file changes
+    autoWatch: false,
+
+    // Continuous Integration mode
+    // if true, Karma captures browsers, runs the tests and exits
+    singleRun: true,
+
+    // Increase timeout in case connection is slow/we run more browsers than possible
+    // (we currently get 3 for free, and we try to run 7, so it can take a while)
+    captureTimeout: 240000,
+
+    // similarly to above
+    browserNoActivityTimeout: 100000,
+  };
+
+  if (useSauce) {
+    my_conf.captureTimeout = 0; // use SL timeout
+    my_conf.sauceLabs = {
+      testName: 'noVNC Tests (all)',
+      startConnect: false,
+      tunnelIdentifier: process.env.TRAVIS_JOB_NUMBER
+    };
+  }
+
+  config.set(my_conf);
+};

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "noVNC",
+  "version": "0.5.1",
+  "description": "An HTML5 VNC client",
+  "main": "karma.conf.js",
+  "directories": {
+    "doc": "docs",
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "PATH=$PATH:node_modules/karma/bin karma start karma.conf.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kanaka/noVNC.git"
+  },
+  "author": "Joel Martin <github@martintribe.org> (https://github.com/kanaka)",
+  "contributors": [
+    "Solly Ross <sross@redhat.com> (https://github.com/directxman12)",
+    "Peter Åstrand <astrand@cendio.se> (https://github.com/astrand)",
+    "Samuel Mannehed <samuel@cendio.se> (https://github.com/samhed)"
+  ],
+  "license": "MPL 2.0",
+  "bugs": {
+    "url": "https://github.com/kanaka/noVNC/issues"
+  },
+  "homepage": "https://github.com/kanaka/noVNC",
+  "devDependencies": {
+    "ansi": "^0.3.0",
+    "casperjs": "^1.1.0-beta3",
+    "chai": "^2.1.0",
+    "commander": "^2.6.0",
+    "karma": "^0.12.31",
+    "karma-chai": "^0.1.0",
+    "karma-mocha": "^0.1.10",
+    "karma-mocha-reporter": "^1.0.0",
+    "karma-phantomjs-launcher": "^0.1.4",
+    "karma-sauce-launcher": "^0.2.10",
+    "karma-sinon": "^1.0.4",
+    "karma-sinon-chai-latest": "^0.1.0",
+    "mocha": "^2.1.0",
+    "open": "^0.0.5",
+    "phantom": "^0.7.2",
+    "phantomjs": "^1.9.15",
+    "sinon": "^1.12.2",
+    "sinon-chai": "^2.7.0",
+    "spooky": "^0.2.5",
+    "temp": "^0.8.1"
+  }
+}

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/self.pem

@@ -0,0 +1,50 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDPM7aLSTwk3IM3
+OmPT4iBWHnS6dpMtF6sf3t9HE7piJ0RlSzmmWuONG2JyafV2Tuc+y8tMGE0ygIsS
+RuOUWPDuwjA2TMZF1SDM9it9jVmfDHfQOL3rHgDIBArf8m19fTM9PRViHrhKmXIM
+lF+tCtXuP8XIAG5lzAKOtl1xuPNHO45A49ttSAT/z0zkGNQaN9UOtoBmbSaGZCDY
+zdjSdRt5+61ccXGxDIykbppP3Oyn/0AOZx5SEHC7kHURAMJ8BhipdLPlr1vzay0B
+4wEQGzg+O5rV750kYDR6gEWonuXlTuJ12pBrxrxOmr9DexC7XrR2z8JltZjLmqss
+Ixgd5q9XAgMBAAECggEBAJZXL1xhBwK3/X1VIJncuRnDf27MGn3dbozxaZBpABO3
+6iiVLH9H81OvSv85YqE1HxSxShEskNbT7hSU2wwIfMjAnbrIehSxT9tnwqaWqTB+
+G3E5upOecXKvfDSB8m/bKBKG/7zyDUYTkG0QO1uTQSZdn2Q+69tw62ohaCvbxqkn
+fewGPZW7/AfNCSDrRTnsWxx8F9E30QSrs4XiObFZ0nDa6aJwSDAXUFhSW1WgYRuE
+x7tnf2loVYska1+j+iiFa8CGFtzu1CpI3MKzNJDyecoYr04lseUlkKKyipKt82mB
+VFN8AVJFXicWvxK9k1kjY09aO7mbgvkVzAGqMSnTFAECgYEA+mQgJaiIR80sc0lI
+NpDzk/RoWZ0u83Lci4plQlAyAyov/s6V9zrp2yrc9HCi8pvx66z2SMijckT+Lc7J
+3TN34mMD0nSdbEmgAelv+QaL4QsUQ6seR7OLmkY+JZHFQWQ+16x9BuVCpER+VtSz
+PC37ix7xQDvT+hEEd2shZsHP9r8CgYEA09frG/L0A89bb+zhSv0c3MqW6hLkbrPD
+O3ThhuYThtq/0xcxYtuboK4ZH0hWR5e8K7kL6L2VT9gcfl1Z5pgmDI1+iWSiuh95
+ILJgeQbwGeN2n1BCsLAZ6WfsbvaAt1P8wlG4CqeOg6Tfj9UhNT+Rsdsn1niocXtm
+oIFRWsUnRWkCgYBRsDrArnQPoMNgtUbG7pFY8sLcgahgqleDetpAQTOfzrKr2bAZ
+YXIMG7bMVLcEmZXagqoy4qpYTGP0g+NdtD3ncNA9Z+g3/Okj1om+X8Fg4SFyVjBh
+yhTAdywtS5pkFBVgfZiomEEeoG3rXCdBeer331dr0lj823Jul1flU1PKtwKBgQDF
+SAcDeDYWdjzI9ui4VQ9T7rasNfvVvELMVATTA+CbbYvGoYq0bZ94+6kZoNv4wC3U
+6fdVP3iVasTeSUE3pemJNxvoB3gjrLu432VIUFW5RkNqCeyRbu4ylz1v+M/V6rkw
+nbmu8mud3ST1ZZ4PYKvl3hozeRok1K62OrfwuDniQQKBgQD4XVw3lpYFHEb3tE5e
+SOWK9eybwtJ+MbMe/9hsWkz7yOd7RZCCmvpFpd6OID/StcxF21IKhah7lkNlffkm
+1O5XDBHnZdGdtKKg+nXaQS6Bb8ZUBJWpRulXxg9OseZUblsmUbKfVjd6sNM0szBu
+kYiD6taBZ3qa6fSq0UGVnSHNNA==
+-----END PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIIDlTCCAn2gAwIBAgIJAKR+g6/myd1jMA0GCSqGSIb3DQEBBQUAMGExCzAJBgNV
+BAYTAnhhMQswCQYDVQQIDAJ4YTELMAkGA1UEBwwCeGExCzAJBgNVBAoMAnhhMQsw
+CQYDVQQLDAJ4YTELMAkGA1UEAwwCeGExETAPBgkqhkiG9w0BCQEWAnhhMB4XDTE1
+MTAyNzA5MzczMFoXDTE2MTAyNjA5MzczMFowYTELMAkGA1UEBhMCeGExCzAJBgNV
+BAgMAnhhMQswCQYDVQQHDAJ4YTELMAkGA1UECgwCeGExCzAJBgNVBAsMAnhhMQsw
+CQYDVQQDDAJ4YTERMA8GCSqGSIb3DQEJARYCeGEwggEiMA0GCSqGSIb3DQEBAQUA
+A4IBDwAwggEKAoIBAQDPM7aLSTwk3IM3OmPT4iBWHnS6dpMtF6sf3t9HE7piJ0Rl
+SzmmWuONG2JyafV2Tuc+y8tMGE0ygIsSRuOUWPDuwjA2TMZF1SDM9it9jVmfDHfQ
+OL3rHgDIBArf8m19fTM9PRViHrhKmXIMlF+tCtXuP8XIAG5lzAKOtl1xuPNHO45A
+49ttSAT/z0zkGNQaN9UOtoBmbSaGZCDYzdjSdRt5+61ccXGxDIykbppP3Oyn/0AO
+Zx5SEHC7kHURAMJ8BhipdLPlr1vzay0B4wEQGzg+O5rV750kYDR6gEWonuXlTuJ1
+2pBrxrxOmr9DexC7XrR2z8JltZjLmqssIxgd5q9XAgMBAAGjUDBOMB0GA1UdDgQW
+BBTVZ67LkIExA0CN2LlKeteHe6OMdTAfBgNVHSMEGDAWgBTVZ67LkIExA0CN2LlK
+eteHe6OMdTAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4IBAQC8jYxOd2/E
+qs3w60mbUtYOyC/REjueS6UX5eslNaqCv8nGHd8KbiPiykLWBUWwqZdCP8gstTtw
+sSC9ctAVW2HdxwfFcMUCyaMgC4CTP4JP9Rzzm0QK+zR7mwYcommBMcDoXzwpv2Uz
+eu4Q4CCdlvT3+gg71RjWWnXwwXHXSkvSav6MdR0P3d2P799xK5qsCmwl6sFBtaPT
+L80hoTC6C4dUSqJzpHG/geWt2jCh8ZNqWNp2Z77mAZ1bFE185ZN3cR2tIb8joou1
+tYpVgckYda1BeQ6bUeufwtsbmm8tPodpnqB7ED6/IqVqXSX+lpBhAcf9/lWigP4y
+uj98hGEMTjHw
+-----END CERTIFICATE-----

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/utils/README.md

@@ -0,0 +1,14 @@
+## WebSockets Proxy/Bridge
+
+Websockify has been forked out into its own project.  `launch.sh` wil
+automatically download it here if it is not already present and not
+installed as system-wide.
+
+For more detailed description and usage information please refer to
+the [websockify README](https://github.com/kanaka/websockify/blob/master/README.md).
+
+The other versions of websockify (C, Node.js) and the associated test
+programs have been moved to
+[websockify](https://github.com/kanaka/websockify).  Websockify was
+formerly named wsproxy.
+

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/utils/img2js.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+
+#
+# Convert image to Javascript compatible base64 Data URI
+# Copyright 2011 Joel Martin
+# Licensed under MPL 2.0 (see docs/LICENSE.MPL-2.0)
+#
+
+import sys, base64
+
+try:
+    from PIL import Image
+except:
+    print "python PIL module required (python-imaging package)"
+    sys.exit(1)
+
+
+if len(sys.argv) < 3:
+    print "Usage: %s IMAGE JS_VARIABLE" % sys.argv[0]
+    sys.exit(1)
+
+fname = sys.argv[1]
+var   = sys.argv[2]
+
+ext = fname.lower().split('.')[-1]
+if   ext == "png":            mime = "image/png"
+elif ext in ["jpg", "jpeg"]:  mime = "image/jpeg"
+elif ext == "gif":            mime = "image/gif"
+else:
+    print "Only PNG, JPEG and GIF images are supported"
+    sys.exit(1)
+uri = "data:%s;base64," % mime
+
+im = Image.open(fname)
+w, h = im.size
+
+raw = open(fname).read()
+
+print '%s = {"width": %s, "height": %s, "data": "%s%s"};' % (
+        var, w, h, uri, base64.b64encode(raw))

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/utils/json2graph.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python
+
+'''
+Use matplotlib to generate performance charts
+Copyright 2011 Joel Martin
+Licensed under MPL-2.0 (see docs/LICENSE.MPL-2.0)
+'''
+
+# a bar plot with errorbars
+import sys, json, pprint
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.font_manager import FontProperties
+
+def usage():
+    print "%s json_file level1 level2 level3 [legend_height]\n\n" % sys.argv[0]
+    print "Description:\n"
+    print "level1, level2, and level3 are one each of the following:\n";
+    print "  select=ITEM - select only ITEM at this level";
+    print "  bar         - each item on this level becomes a graph bar";
+    print "  group       - items on this level become groups of bars";
+    print "\n";
+    print "json_file is a file containing json data in the following format:\n"
+    print '  {';
+    print '    "conf": {';
+    print '      "order_l1": [';
+    print '        "level1_label1",';
+    print '        "level1_label2",';
+    print '        ...';
+    print '      ],';
+    print '      "order_l2": [';
+    print '        "level2_label1",';
+    print '        "level2_label2",';
+    print '        ...';
+    print '      ],';
+    print '      "order_l3": [';
+    print '        "level3_label1",';
+    print '        "level3_label2",';
+    print '        ...';
+    print '      ]';
+    print '    },';
+    print '    "stats": {';
+    print '      "level1_label1": {';
+    print '        "level2_label1": {';
+    print '          "level3_label1": [val1, val2, val3],';
+    print '          "level3_label2": [val1, val2, val3],';
+    print '          ...';
+    print '        },';
+    print '        "level2_label2": {';
+    print '        ...';
+    print '        },';
+    print '      },';
+    print '      "level1_label2": {';
+    print '        ...';
+    print '      },';
+    print '      ...';
+    print '    },';
+    print '  }';
+    sys.exit(2)
+
+def error(msg):
+    print msg
+    sys.exit(1)
+
+
+#colors = ['#ff0000', '#0863e9', '#00f200', '#ffa100',
+#          '#800000', '#805100', '#013075', '#007900']
+colors = ['#ff0000', '#00ff00', '#0000ff',
+          '#dddd00', '#dd00dd', '#00dddd',
+          '#dd6622', '#dd2266', '#66dd22',
+          '#8844dd', '#44dd88', '#4488dd']
+
+if len(sys.argv) < 5:
+    usage()
+
+filename = sys.argv[1]
+L1 = sys.argv[2]
+L2 = sys.argv[3]
+L3 = sys.argv[4]
+if len(sys.argv) > 5:
+    legendHeight = float(sys.argv[5])
+else:
+    legendHeight = 0.75
+
+# Load the JSON data from the file
+data = json.loads(file(filename).read())
+conf = data['conf']
+stats = data['stats']
+
+# Sanity check data hierarchy
+if len(conf['order_l1']) != len(stats.keys()):
+    error("conf.order_l1 does not match stats level 1")
+for l1 in stats.keys():
+    if len(conf['order_l2']) != len(stats[l1].keys()):
+        error("conf.order_l2 does not match stats level 2 for %s" % l1)
+    if conf['order_l1'].count(l1) < 1:
+        error("%s not found in conf.order_l1" % l1)
+    for l2 in stats[l1].keys():
+        if len(conf['order_l3']) != len(stats[l1][l2].keys()):
+            error("conf.order_l3 does not match stats level 3")
+        if conf['order_l2'].count(l2) < 1:
+            error("%s not found in conf.order_l2" % l2)
+        for l3 in stats[l1][l2].keys():
+            if conf['order_l3'].count(l3) < 1:
+                error("%s not found in conf.order_l3" % l3)
+
+#
+# Generate the data based on the level specifications
+#
+bar_labels = None
+group_labels = None
+bar_vals = []
+bar_sdvs = []
+if L3.startswith("select="):
+    select_label = l3 = L3.split("=")[1]
+    bar_labels = conf['order_l1']
+    group_labels = conf['order_l2']
+    bar_vals = [[0]*len(group_labels) for i in bar_labels]
+    bar_sdvs = [[0]*len(group_labels) for i in bar_labels]
+    for b in range(len(bar_labels)):
+        l1 = bar_labels[b]
+        for g in range(len(group_labels)):
+            l2 = group_labels[g]
+            bar_vals[b][g] = np.mean(stats[l1][l2][l3])
+            bar_sdvs[b][g] = np.std(stats[l1][l2][l3])
+elif L2.startswith("select="):
+    select_label = l2 = L2.split("=")[1]
+    bar_labels = conf['order_l1']
+    group_labels = conf['order_l3']
+    bar_vals = [[0]*len(group_labels) for i in bar_labels]
+    bar_sdvs = [[0]*len(group_labels) for i in bar_labels]
+    for b in range(len(bar_labels)):
+        l1 = bar_labels[b]
+        for g in range(len(group_labels)):
+            l3 = group_labels[g]
+            bar_vals[b][g] = np.mean(stats[l1][l2][l3])
+            bar_sdvs[b][g] = np.std(stats[l1][l2][l3])
+elif L1.startswith("select="):
+    select_label = l1 = L1.split("=")[1]
+    bar_labels = conf['order_l2']
+    group_labels = conf['order_l3']
+    bar_vals = [[0]*len(group_labels) for i in bar_labels]
+    bar_sdvs = [[0]*len(group_labels) for i in bar_labels]
+    for b in range(len(bar_labels)):
+        l2 = bar_labels[b]
+        for g in range(len(group_labels)):
+            l3 = group_labels[g]
+            bar_vals[b][g] = np.mean(stats[l1][l2][l3])
+            bar_sdvs[b][g] = np.std(stats[l1][l2][l3])
+else:
+    usage()
+
+# If group is before bar then flip (zip) the data
+if [L1, L2, L3].index("group") < [L1, L2, L3].index("bar"):
+    bar_labels, group_labels = group_labels, bar_labels
+    bar_vals = zip(*bar_vals)
+    bar_sdvs = zip(*bar_sdvs)
+
+print "bar_vals:", bar_vals
+
+#
+# Now render the bar graph
+#
+ind = np.arange(len(group_labels))  # the x locations for the groups
+width = 0.8 * (1.0/len(bar_labels)) # the width of the bars
+
+fig = plt.figure(figsize=(10,6), dpi=80)
+plot = fig.add_subplot(1, 1, 1)
+
+rects = []
+for i in range(len(bar_vals)):
+    rects.append(plot.bar(ind+width*i, bar_vals[i], width, color=colors[i],
+                          yerr=bar_sdvs[i], align='center'))
+
+# add some
+plot.set_ylabel('Milliseconds (less is better)')
+plot.set_title("Javascript array test: %s" % select_label)
+plot.set_xticks(ind+width)
+plot.set_xticklabels( group_labels )
+
+fontP = FontProperties()
+fontP.set_size('small')
+plot.legend( [r[0] for r in rects], bar_labels, prop=fontP,
+            loc = 'center right', bbox_to_anchor = (1.0, legendHeight))
+
+def autolabel(rects):
+    # attach some text labels
+    for rect in rects:
+        height = rect.get_height()
+        if np.isnan(height):
+            height = 0.0
+        plot.text(rect.get_x()+rect.get_width()/2., height+20, '%d'%int(height),
+                ha='center', va='bottom', size='7')
+
+for rect in rects:
+    autolabel(rect)
+
+# Adjust axis sizes
+axis = list(plot.axis())
+axis[0] = -width          # Make sure left side has enough for bar
+#axis[1] = axis[1] * 1.20  # Add 20% to the right to make sure it fits
+axis[2] = 0               # Make y-axis start at 0
+axis[3] = axis[3] * 1.10  # Add 10% to the top
+plot.axis(axis)
+
+plt.show()

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/utils/killport.sh

@@ -0,0 +1,55 @@
+#!/bin/sh
+
+portnb="6801";
+sumnb="1";
+
+usage() {
+    if [ "$*" ]; then
+	echo
+        echo "$*"
+    fi
+    echo "Usage: ${NAME} [-p] [-s] ";
+    echo "    -p                    port number";
+    echo "                          Default: 6801";
+    echo "    -n                    port sum,start for [-p]6801";
+    echo "                          Default: 20";
+    exit 2
+}
+
+while [ "$*" ]; do
+    param=$1; shift; OPTARG=$1
+    case $param in
+    -p)  portnb="${OPTARG}"; shift              ;;
+    -n)  sumnb="${OPTARG}"; shift               ;;
+    -h|--help) usage                            ;;
+    -*) usage "Unknown chrooter option: ${param}" ;;
+    *) break                                      ;;
+    esac
+done
+
+
+expr $portnb "+" 10 &> /dev/null 
+if [ $? -eq 0 ];then
+  echo -e "\033[34;5;5mkill port exec!\033[0m ";
+else
+  echo "[-p]erro : please input a number!";
+  exit 2;
+fi
+
+expr $sumnb "+" 10 &> /dev/null 
+if [ $? -eq 0 ];then
+  echo -e "\033[34;5;5mkill port exec!\033[0m ";
+else
+  echo "[-n]erro : please input a number!";
+  exit 2;
+fi
+
+for i in `seq 1 $sumnb`;do
+  typeset -i port=$portnb-1+i
+
+  vwport=`netstat -tlnp | grep ":"$port`;
+  if [ -n "$vwport" ];then
+    echo -e "kill port : \033[32;5;5m$port\033[0m succeed! ";
+    kill -9 `lsof -ti":$port"`;
+  fi
+done

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/utils/launch.sh

@@ -0,0 +1,150 @@
+#!/bin/bash
+
+usage() {
+    if [ "$*" ]; then
+        echo "$*"
+        echo
+    fi
+    echo "Usage: ${NAME} [--listen PORT] [--vnc VNC_HOST:PORT] [--cert CERT]"
+    echo
+    echo "Starts the WebSockets proxy and a mini-webserver and "
+    echo "provides a cut-and-paste URL to go to."
+    echo
+    echo "    --listen PORT         Port for proxy/webserver to listen on"
+    echo "                          Default: 6080"
+    echo "    --vnc VNC_HOST:PORT   VNC server host:port proxy target"
+    echo "                          Default: localhost:5900"
+    echo "    --cert CERT           Path to combined cert/key file"
+    echo "                          Default: self.pem"
+    echo "    --web WEB             Path to web files (e.g. vnc.html)"
+    echo "                          Default: ./"
+    exit 2
+}
+
+NAME="$(basename $0)"
+REAL_NAME="$(readlink -f $0)"
+HERE="$(cd "$(dirname "$REAL_NAME")" && pwd)"
+PORT="6080"
+VNC_DEST="localhost:5900"
+CERT=""
+WEB=""
+proxy_pid=""
+
+die() {
+    echo "$*"
+    exit 1
+}
+
+cleanup() {
+    trap - TERM QUIT INT EXIT
+    trap "true" CHLD   # Ignore cleanup messages
+    echo
+    if [ -n "${proxy_pid}" ]; then
+        echo "Terminating WebSockets proxy (${proxy_pid})"
+        kill ${proxy_pid}
+    fi
+}
+
+# Process Arguments
+
+# Arguments that only apply to chrooter itself
+while [ "$*" ]; do
+    param=$1; shift; OPTARG=$1
+    case $param in
+    --listen)  PORT="${OPTARG}"; shift            ;;
+    --vnc)     VNC_DEST="${OPTARG}"; shift        ;;
+    --cert)    CERT="${OPTARG}"; shift            ;;
+    --web)     WEB="${OPTARG}"; shift            ;;
+    -h|--help) usage                              ;;
+    -*) usage "Unknown chrooter option: ${param}" ;;
+    *) break                                      ;;
+    esac
+done
+
+# Sanity checks
+which netstat >/dev/null 2>&1 \
+    || die "Must have netstat installed"
+
+netstat -ltn | grep -qs "${PORT} .*LISTEN" \
+    && die "Port ${PORT} in use. Try --listen PORT"
+
+trap "cleanup" TERM QUIT INT EXIT
+
+# Find vnc.html
+if [ -n "${WEB}" ]; then
+    if [ ! -e "${WEB}/vnc.html" ]; then
+        die "Could not find ${WEB}/vnc.html"
+    fi
+elif [ -e "$(pwd)/vnc.html" ]; then
+    WEB=$(pwd)
+elif [ -e "${HERE}/../vnc.html" ]; then
+    WEB=${HERE}/../
+elif [ -e "${HERE}/vnc.html" ]; then
+    WEB=${HERE}
+elif [ -e "${HERE}/../share/novnc/vnc.html" ]; then
+    WEB=${HERE}/../share/novnc/
+else
+    die "Could not find vnc.html"
+fi
+
+# Find self.pem
+if [ -n "${CERT}" ]; then
+    if [ ! -e "${CERT}" ]; then
+        die "Could not find ${CERT}"
+    fi
+elif [ -e "$(pwd)/self.pem" ]; then
+    CERT="$(pwd)/self.pem"
+elif [ -e "${HERE}/../self.pem" ]; then
+    CERT="${HERE}/../self.pem"
+elif [ -e "${HERE}/self.pem" ]; then
+    CERT="${HERE}/self.pem"
+else
+    echo "Warning: could not find self.pem"
+fi
+
+# try to find websockify (prefer local, try global, then download local)
+if [[ -e ${HERE}/websockify ]]; then
+    WEBSOCKIFY=${HERE}/websockify/run
+
+    if [[ ! -x $WEBSOCKIFY ]]; then
+        echo "The path ${HERE}/websockify exists, but $WEBSOCKIFY either does not exist or is not executable."
+        echo "If you inteded to use an installed websockify package, please remove ${HERE}/websockify."
+        exit 1
+    fi
+
+    echo "Using local websockify at $WEBSOCKIFY"
+else
+    WEBSOCKIFY=$(which websockify 2>/dev/null)
+
+    if [[ $? -ne 0 ]]; then
+        echo "No installed websockify, attempting to clone websockify..."
+        WEBSOCKIFY=${HERE}/websockify/run
+        git clone https://github.com/kanaka/websockify ${HERE}/websockify
+
+        if [[ ! -e $WEBSOCKIFY ]]; then
+            echo "Unable to locate ${HERE}/websockify/run after downloading"
+            exit 1
+        fi
+
+        echo "Using local websockify at $WEBSOCKIFY"
+    else
+        echo "Using installed websockify at $WEBSOCKIFY"
+    fi
+fi
+
+echo "Starting webserver and WebSockets proxy on port ${PORT}"
+#${HERE}/websockify --web ${WEB} ${CERT:+--cert ${CERT}} ${PORT} ${VNC_DEST} &
+${WEBSOCKIFY} --web ${WEB} ${CERT:+--cert ${CERT}} ${PORT} ${VNC_DEST} &
+proxy_pid="$!"
+sleep 1
+if ! ps -p ${proxy_pid} >/dev/null; then
+    proxy_pid=
+    echo "Failed to start WebSockets proxy"
+    exit 1
+fi
+
+echo -e "\n\nNavigate to this URL:\n"
+echo -e "    http://$(hostname):${PORT}/vnc.html?host=$(hostname)&port=${PORT}\n"
+echo -e "Press Ctrl-C to exit\n\n"
+
+wait ${proxy_pid}

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/utils/parse.js

@@ -0,0 +1,97 @@
+// Utility to parse keysymdef.h to produce mappings from Unicode codepoints to keysyms
+"use strict";
+
+var fs = require('fs');
+
+var show_help = process.argv.length === 2;
+var use_keynames = false;
+var filename;
+
+for (var i = 2; i < process.argv.length; ++i) {
+  switch (process.argv[i]) {
+    case "--help":
+    case "-h":
+      show_help = true;
+      break;
+    case "--debug-names":
+    case "-d":
+      use_keynames = true;
+      break;
+    case "--file":
+    case "-f":
+    default:
+      filename = process.argv[i];
+  }
+}
+
+if (!filename) {
+  show_help = true;
+  console.log("Error: No filename specified\n");
+}
+
+if (show_help) {
+  console.log("Parses a *nix keysymdef.h to generate Unicode code point mappings");
+  console.log("Usage: node parse.js [options] filename:");
+  console.log("  -h [ --help ]                 Produce this help message");
+  console.log("  -d [ --debug-names ]          Preserve keysym names for debugging (Increases file size by ~40KB)");
+  console.log("  filename                      The keysymdef.h file to parse");
+  return;
+}
+
+// Set this to false to omit key names from the generated keysymdef.js
+// This reduces the file size by around 40kb, but may hinder debugging
+
+var buf = fs.readFileSync(filename);
+var str = buf.toString('utf8');
+
+var re = /^\#define XK_([a-zA-Z_0-9]+)\s+0x([0-9a-fA-F]+)\s*(\/\*\s*(.*)\s*\*\/)?\s*$/m;
+
+var arr = str.split('\n');
+
+var keysyms = {};
+var codepoints = {};
+
+for (var i = 0; i < arr.length; ++i) {
+    var result = re.exec(arr[i]);
+    if (result){
+        var keyname = result[1];
+        var keysym = parseInt(result[2], 16);
+        var remainder = result[3];
+
+        keysyms[keysym] = keyname;
+
+        var unicodeRes = /U\+([0-9a-fA-F]+)/.exec(remainder);
+        if (unicodeRes) {
+            var unicode = parseInt(unicodeRes[1], 16);
+            if (!codepoints[unicode]){
+                codepoints[unicode] = keysym;
+            }
+        }
+        else {
+            console.log("no unicode codepoint found:", arr[i]);
+        }
+    }
+    else {
+        console.log("line is not a keysym:", arr[i]);
+    }
+}
+
+var out = "// This file describes mappings from Unicode codepoints to the keysym values\n" +
+"// (and optionally, key names) expected by the RFB protocol\n" +
+"// How this file was generated:\n" +
+"// " + process.argv.join(" ") + "\n" +
+"var keysyms = (function(){\n" +
+"    \"use strict\";\n" +
+"    var keynames = {keysyms};\n" +
+"    var codepoints = {codepoints};\n" +
+"\n" +
+"    function lookup(k) { return k ? {keysym: k, keyname: keynames ? keynames[k] : k} : undefined; }\n" +
+"    return {\n" +
+"        fromUnicode : function(u) { return lookup(codepoints[u]); },\n" +
+"        lookup : lookup\n" +
+"    };\n" +
+"})();\n";
+out = out.replace('{keysyms}', use_keynames ? JSON.stringify(keysyms) : "null");
+out = out.replace('{codepoints}', JSON.stringify(codepoints));
+
+fs.writeFileSync("keysymdef.js", out);

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/utils/u2x11

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+#
+# Convert "U+..." commented entries in /usr/include/X11/keysymdef.h
+# into JavaScript for use by noVNC.  Note this is likely to produce
+# a few duplicate properties with clashing values, that will need
+# resolving manually.
+#
+# Colin Dean <colin@xvpsource.org>
+#
+
+regex="^#define[ \t]+XK_[A-Za-z0-9_]+[ \t]+0x([0-9a-fA-F]+)[ \t]+\/\*[ \t]+U\+([0-9a-fA-F]+)[ \t]+[^*]+.[ \t]+\*\/[ \t]*$"
+echo "unicodeTable = {"
+while read line; do
+    if echo "${line}" | egrep -qs "${regex}"; then
+
+        x11=$(echo "${line}" | sed -r "s/${regex}/\1/")
+        vnc=$(echo "${line}" | sed -r "s/${regex}/\2/")
+	
+	if echo "${vnc}" | egrep -qs "^00[2-9A-F][0-9A-F]$"; then
+	    : # skip ISO Latin-1 (U+0020 to U+00FF) as 1-to-1 mapping
+	else
+	    # note 1-to-1 is possible (e.g. for Euro symbol, U+20AC)
+	    echo "    0x${vnc} : 0x${x11},"
+	fi
+    fi
+done < /usr/include/X11/keysymdef.h | uniq
+echo "};"
+

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/vnc.html

@@ -0,0 +1,229 @@
+<!DOCTYPE html>
+<html>
+<head>
+
+    <!--
+    noVNC example: simple example using default UI
+    Copyright (C) 2012 Joel Martin
+    Copyright (C) 2013 Samuel Mannehed for Cendio AB
+    noVNC is licensed under the MPL 2.0 (see LICENSE.txt)
+    This file is licensed under the 2-Clause BSD license (see LICENSE.txt).
+
+    Connect parameters are provided in query string:
+        http://example.com/?host=HOST&port=PORT&encrypt=1&true_color=1
+    -->
+    <title>noVNC</title>
+
+    <meta charset="utf-8">
+
+    <!-- Always force latest IE rendering engine (even in intranet) & Chrome Frame
+                Remove this if you use the .htaccess -->
+    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
+
+    <!-- Apple iOS Safari settings -->
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+    <!-- App Start Icon  -->
+    <link rel="apple-touch-startup-image" href="images/screen_320x460.png" />
+    <!-- For iOS devices set the icon to use if user bookmarks app on their homescreen -->
+    <link rel="apple-touch-icon" href="images/screen_57x57.png">
+    <!--
+    <link rel="apple-touch-icon-precomposed" href="images/screen_57x57.png" />
+    -->
+
+
+    <!-- Stylesheets -->
+    <link rel="stylesheet" href="include/base.css" />
+    <link rel="alternate stylesheet" href="include/black.css" TITLE="Black" />
+    <link rel="alternate stylesheet" href="include/blue.css" TITLE="Blue" />
+
+    <!--
+    <script type='text/javascript'
+        src='http://getfirebug.com/releases/lite/1.2/firebug-lite-compressed.js'></script>
+    -->
+
+</head>
+
+<body>
+    <div id="noVNC-control-bar" class="noVNC_status_normal">
+        <!--noVNC Mobile Device only Buttons-->
+        <div class="noVNC-buttons-left">
+            <input type="image" alt="viewport drag" src="images/drag.png"
+                id="noVNC_view_drag_button" class="noVNC_status_button"
+                title="Move/Drag Viewport">
+            <div id="noVNC_mobile_buttons">
+                <input type="image" alt="No mousebutton" src="images/mouse_none.png"
+                    id="noVNC_mouse_button0" class="noVNC_status_button">
+                <input type="image" alt="Left mousebutton" src="images/mouse_left.png"
+                    id="noVNC_mouse_button1" class="noVNC_status_button">
+                <input type="image" alt="Middle mousebutton" src="images/mouse_middle.png"
+                    id="noVNC_mouse_button2" class="noVNC_status_button">
+                <input type="image" alt="Right mousebutton" src="images/mouse_right.png"
+                    id="noVNC_mouse_button4" class="noVNC_status_button">
+                <input type="image" alt="Keyboard" src="images/keyboard.png"
+                    id="showKeyboard" class="noVNC_status_button"
+                    value="Keyboard" title="Show Keyboard"/>
+                <!-- Note that Google Chrome on Android doesn't respect any of these,
+                     html attributes which attempt to disable text suggestions on the
+                     on-screen keyboard. Let's hope Chrome implements the ime-mode
+                     style for example -->
+                <textarea id="keyboardinput" autocapitalize="off"
+                    autocorrect="off" autocomplete="off" spellcheck="false"
+                    mozactionhint="Enter"></textarea>
+                <div id="noVNC_extra_keys">
+                    <input type="image" alt="Extra keys" src="images/showextrakeys.png"
+                        id="showExtraKeysButton" class="noVNC_status_button">
+                    <input type="image" alt="Ctrl" src="images/ctrl.png"
+                        id="toggleCtrlButton" class="noVNC_status_button">
+                    <input type="image" alt="Alt" src="images/alt.png"
+                        id="toggleAltButton" class="noVNC_status_button">
+                    <input type="image" alt="Tab" src="images/tab.png"
+                        id="sendTabButton" class="noVNC_status_button">
+                    <input type="image" alt="Esc" src="images/esc.png"
+                        id="sendEscButton" class="noVNC_status_button">
+                </div>
+            </div>
+        </div>
+
+        <div id="noVNC_status"></div>
+
+        <!--noVNC Buttons-->
+        <div class="noVNC-buttons-right">
+            <!--<input type="image" alt="Ctrl+Alt+Del" src="images/ctrlaltdel.png"
+                id="sendCtrlAltDelButton" class="noVNC_status_button"
+                title="Send Ctrl-Alt-Del" />
+            <input type="image" alt="Shutdown/Reboot" src="images/power.png"
+                id="xvpButton" class="noVNC_status_button"
+                title="Shutdown/Reboot..." />
+            <input type="image" alt="Clipboard" src="images/clipboard.png"
+                id="clipboardButton" class="noVNC_status_button"
+                title="Clipboard" />
+            <input type="image" alt="Settings" src="images/settings.png"
+                id="settingsButton" class="noVNC_status_button"
+                title="Settings" />-->
+            <input type="image" alt="Connect" src="images/connect.png"
+                id="connectButton" class="noVNC_status_button"
+                title="Connect" />
+            <input type="image" alt="Disconnect" src="images/disconnect.png"
+                id="disconnectButton" class="noVNC_status_button"
+                title="Disconnect" />
+        </div>
+
+        <!-- Description Panel -->
+        <!-- Shown by default when hosted at for kanaka.github.com -->
+        <div id="noVNC_description" class="">
+            noVNC is a browser based VNC client implemented using HTML5 Canvas
+            and WebSockets. You will either need a VNC server with WebSockets
+            support (such as <a href="http://libvncserver.sourceforge.net/">libvncserver</a>)
+            or you will need to use
+            <a href="https://github.com/kanaka/websockify">websockify</a>
+            to bridge between your browser and VNC server. See the noVNC
+            <a href="https://github.com/kanaka/noVNC">README</a>
+            and <a href="http://kanaka.github.com/noVNC">website</a>
+            for more information.
+            <br />
+            <input id="descriptionButton" type="button" value="Close">
+        </div>
+
+        <!-- Popup Status Panel -->
+        <div id="noVNC_popup_status_panel" class="">
+        </div>
+
+        <!-- Clipboard Panel -->
+        <div id="noVNC_clipboard" class="triangle-right top">
+            <textarea id="noVNC_clipboard_text" rows=5>
+            </textarea>
+            <br />
+            <input id="noVNC_clipboard_clear_button" type="button"
+                value="Clear">
+        </div>
+
+        <!-- XVP Shutdown/Reboot Panel -->
+        <div id="noVNC_xvp" class="triangle-right top">
+            <span id="noVNC_xvp_menu">
+                <input type="button" id="xvpShutdownButton" value="Shutdown" />
+                <input type="button" id="xvpRebootButton" value="Reboot" />
+                <input type="button" id="xvpResetButton" value="Reset" />
+            </span>
+        </div>
+
+        <!-- Settings Panel -->
+        <div id="noVNC_settings" class="triangle-right top">
+            <span id="noVNC_settings_menu">
+                <ul>
+                    <li><input id="noVNC_encrypt" type="checkbox"> Encrypt</li>
+                    <li><input id="noVNC_true_color" type="checkbox" checked> True Color</li>
+                    <li><input id="noVNC_cursor" type="checkbox"> Local Cursor</li>
+                    <li><input id="noVNC_clip" type="checkbox"> Clip to Window</li>
+                    <li><input id="noVNC_shared" type="checkbox"> Shared Mode</li>
+                    <li><input id="noVNC_view_only" type="checkbox"> View Only</li>
+                    <hr>
+                    <li><input id="noVNC_path" type="input" value="websockify"> Path</li>
+                    <li><label>
+                        <select id="noVNC_resize" name="vncResize">
+                            <option value="off">None</option>
+                            <option value="scale">Local Scaling</option>
+                            <option value="downscale">Local Downscaling</option>
+                            <option value="remote">Remote Resizing</option>
+                        </select> Scaling Mode</label>
+                    </li>
+                    <li><input id="noVNC_repeaterID" type="input" value=""> Repeater ID</li>
+                    <hr>
+                    <!-- Stylesheet selection dropdown -->
+                    <li><label><strong>Style: </strong>
+                        <select id="noVNC_stylesheet" name="vncStyle">
+                            <option value="default">default</option>
+                        </select></label>
+                    </li>
+
+                    <!-- Logging selection dropdown -->
+                    <li><label><strong>Logging: </strong>
+                        <select id="noVNC_logging" name="vncLogging">
+                        </select></label>
+                    </li>
+                    <hr>
+                    <li><input type="button" id="noVNC_apply" value="Apply"></li>
+                </ul>
+            </span>
+        </div>
+
+        <!-- Connection Panel -->
+        <div id="noVNC_controls" class="triangle-right top">
+            <ul>
+                <li><label><strong>Host: </strong><input id="noVNC_host" /></label></li>
+                <li><label><strong>Port: </strong><input id="noVNC_port" /></label></li>
+                <li><label><strong>Password: </strong><input id="noVNC_password" type="password" /></label></li>
+                <li><input id="noVNC_connect_button" type="button" value="Connect"></li>
+            </ul>
+        </div>
+
+    </div> <!-- End of noVNC-control-bar -->
+
+
+    <div id="noVNC_screen">
+       <!-- <h1 id="noVNC_logo"><span>no</span><br />VNC</h1>-->
+
+        <!-- HTML5 Canvas -->
+        <div id="noVNC_container">
+            <canvas id="noVNC_canvas" width="0" height="0">
+                        Canvas not supported.
+            </canvas>
+        </div>
+
+    </div>
+    <script src="include/util.js"></script>
+    <script src="include/ui.js"></script>
+<script type="text/javascript">
+window.onload=function(){ 
+fn();
+};
+    function fn(){
+	var a = document.getElementById('noVNC_connect_button');
+        a.click();
+    }
+fn();
+</script>
+ </body>
+</html>
+

rpmbuild/SOURCES/smarttms/apache-tomcat-7.0.63/webapps/noVNC-master/vnc_auto.html

@@ -0,0 +1,242 @@
+<!DOCTYPE html>
+<html>
+<head>
+
+    <!--
+    noVNC example: simple example using default UI
+    Copyright (C) 2012 Joel Martin
+    Copyright (C) 2013 Samuel Mannehed for Cendio AB
+    noVNC is licensed under the MPL 2.0 (see LICENSE.txt)
+    This file is licensed under the 2-Clause BSD license (see LICENSE.txt).
+
+    Connect parameters are provided in query string:
+        http://example.com/?host=HOST&port=PORT&encrypt=1&true_color=1
+    -->
+    <title>noVNC</title>
+
+    <meta charset="utf-8">
+
+    <!-- Always force latest IE rendering engine (even in intranet) & Chrome Frame
+                Remove this if you use the .htaccess -->
+    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
+
+    <!-- Apple iOS Safari settings -->
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+    <!-- App Start Icon  -->
+    <link rel="apple-touch-startup-image" href="images/screen_320x460.png" />
+    <!-- For iOS devices set the icon to use if user bookmarks app on their homescreen -->
+    <link rel="apple-touch-icon" href="images/screen_57x57.png">
+    <!--
+    <link rel="apple-touch-icon-precomposed" href="images/screen_57x57.png" />
+    -->
+
+
+    <!-- Stylesheets -->
+    <link rel="stylesheet" href="include/base.css" title="plain">
+
+     <!--
+    <script type='text/javascript'
+        src='http://getfirebug.com/releases/lite/1.2/firebug-lite-compressed.js'></script>
+    -->
+        <script src="include/util.js"></script>
+</head>
+
+<body style="margin: 0px;">
+    <div id="noVNC_screen">
+            <div id="noVNC_status_bar" class="noVNC_status_bar" style="margin-top: 0px;">
+                <table border=0 width="100%"><tr>
+                    <td><div id="noVNC_status" style="position: relative; height: auto;">
+                        Loading
+                    </div></td>
+                    <td width="1%"><div id="noVNC_buttons">
+                        <input type=button value="Send CtrlAltDel"
+                            id="sendCtrlAltDelButton">
+                        <span id="noVNC_xvp_buttons">
+                        <input type=button value="Shutdown"
+                            id="xvpShutdownButton">
+                        <input type=button value="Reboot"
+                            id="xvpRebootButton">
+                        <input type=button value="Reset"
+                            id="xvpResetButton">
+                        </span>
+                            </div></td>
+                </tr></table>
+            </div>
+            <canvas id="noVNC_canvas" width="640px" height="20px">
+                Canvas not supported.
+            </canvas>
+        </div>
+
+        <script>
+        /*jslint white: false */
+        /*global window, $, Util, RFB, */
+        "use strict";
+
+        // Load supporting scripts
+        Util.load_scripts(["webutil.js", "base64.js", "websock.js", "des.js",
+                           "keysymdef.js", "keyboard.js", "input.js", "display.js",
+                           "jsunzip.js", "rfb.js", "keysym.js"]);
+
+        var rfb;
+        var resizeTimeout;
+
+
+        function UIresize() {
+            if (WebUtil.getQueryVar('resize', false)) {
+                var innerW = window.innerWidth;
+                var innerH = window.innerHeight;
+                var controlbarH = $D('noVNC_status_bar').offsetHeight;
+                var padding = 5;
+                if (innerW !== undefined && innerH !== undefined)
+                    rfb.setDesktopSize(innerW, innerH - controlbarH - padding);
+            }
+        }
+        function FBUComplete(rfb, fbu) {
+            UIresize();
+            rfb.set_onFBUComplete(function() { });
+        }
+        function passwordRequired(rfb) {
+            var msg;
+            msg = '<form onsubmit="return setPassword();"';
+            msg += '  style="margin-bottom: 0px">';
+            msg += 'Password Required: ';
+            msg += '<input type=password size=10 id="password_input" class="noVNC_status">';
+            msg += '<\/form>';
+            $D('noVNC_status_bar').setAttribute("class", "noVNC_status_warn");
+            $D('noVNC_status').innerHTML = msg;
+        }
+        function setPassword() {
+            rfb.sendPassword($D('password_input').value);
+            return false;
+        }
+        function sendCtrlAltDel() {
+            rfb.sendCtrlAltDel();
+            return false;
+        }
+        function xvpShutdown() {
+            rfb.xvpShutdown();
+            return false;
+        }
+        function xvpReboot() {
+            rfb.xvpReboot();
+            return false;
+        }
+        function xvpReset() {
+            rfb.xvpReset();
+            return false;
+        }
+        function updateState(rfb, state, oldstate, msg) {
+            var s, sb, cad, level;
+            s = $D('noVNC_status');
+            sb = $D('noVNC_status_bar');
+            cad = $D('sendCtrlAltDelButton');
+            switch (state) {
+                case 'failed':       level = "error";  break;
+                case 'fatal':        level = "error";  break;
+                case 'normal':       level = "normal"; break;
+                case 'disconnected': level = "normal"; break;
+                case 'loaded':       level = "normal"; break;
+                default:             level = "warn";   break;
+            }
+
+            if (state === "normal") {
+                cad.disabled = false;
+            } else {
+                cad.disabled = true;
+                xvpInit(0);
+            }
+
+            if (typeof(msg) !== 'undefined') {
+                sb.setAttribute("class", "noVNC_status_" + level);
+                s.innerHTML = msg;
+            }
+        }
+
+        window.onresize = function () {
+            // When the window has been resized, wait until the size remains
+            // the same for 0.5 seconds before sending the request for changing
+            // the resolution of the session
+            clearTimeout(resizeTimeout);
+            resizeTimeout = setTimeout(function(){
+                UIresize();
+            }, 500);
+        };
+
+        function xvpInit(ver) {
+            var xvpbuttons;
+            xvpbuttons = $D('noVNC_xvp_buttons');
+            if (ver >= 1) {
+                xvpbuttons.style.display = 'inline';
+            } else {
+                xvpbuttons.style.display = 'none';
+            }
+        }
+
+        window.onscriptsload = function () {
+            var host, port, password, path, token;
+
+            $D('sendCtrlAltDelButton').style.display = "inline";
+            $D('sendCtrlAltDelButton').onclick = sendCtrlAltDel;
+            $D('xvpShutdownButton').onclick = xvpShutdown;
+            $D('xvpRebootButton').onclick = xvpReboot;
+            $D('xvpResetButton').onclick = xvpReset;
+
+            WebUtil.init_logging(WebUtil.getQueryVar('logging', 'warn'));
+            document.title = unescape(WebUtil.getQueryVar('title', 'noVNC'));
+            // By default, use the host and port of server that served this file
+            host = WebUtil.getQueryVar('host', window.location.hostname);
+            port = WebUtil.getQueryVar('port', window.location.port);
+
+            // if port == 80 (or 443) then it won't be present and should be
+            // set manually
+            if (!port) {
+                if (window.location.protocol.substring(0,5) == 'https') {
+                    port = 443;
+                }
+                else if (window.location.protocol.substring(0,4) == 'http') {
+                    port = 80;
+                }
+            }
+
+            // If a token variable is passed in, set the parameter in a cookie.
+            // This is used by nova-novncproxy.
+            token = WebUtil.getQueryVar('token', null);
+            if (token) {
+                WebUtil.createCookie('token', token, 1)
+            }
+
+            password = WebUtil.getQueryVar('password', '');
+            path = WebUtil.getQueryVar('path', 'websockify');
+
+            if ((!host) || (!port)) {
+                updateState('failed',
+                    "Must specify host and port in URL");
+                return;
+            }
+
+            try {
+                rfb = new RFB({'target':       $D('noVNC_canvas'),
+                               'encrypt':      WebUtil.getQueryVar('encrypt',
+                                        (window.location.protocol === "https:")),
+                               'repeaterID':   WebUtil.getQueryVar('repeaterID', ''),
+                               'true_color':   WebUtil.getQueryVar('true_color', true),
+                               'local_cursor': WebUtil.getQueryVar('cursor', true),
+                               'shared':       WebUtil.getQueryVar('shared', true),
+                               'view_only':    WebUtil.getQueryVar('view_only', false),
+                               'onUpdateState':  updateState,
+                               'onXvpInit':    xvpInit,
+                               'onPasswordRequired':  passwordRequired,
+                               'onFBUComplete': FBUComplete});
+            } catch (exc) {
+                UI.updateState(null, 'fatal', null, 'Unable to create RFB client -- ' + exc);
+                return; // don't continue trying to connect
+            }
+
+            rfb.connect(host, port, password, path);
+        };
+        </script>
+
+    </body>
+</html>