GuacLite
view release on metacpan or search on metacpan
share/public/guaclite.js view on Meta::CPAN
y /= display.getScale();
}
// Update client-side cursor
display.moveCursor(
Math.floor(x),
Math.floor(y)
);
// Build mask
var buttonMask = 0;
if (mouseState.left) buttonMask |= 1;
if (mouseState.middle) buttonMask |= 2;
if (mouseState.right) buttonMask |= 4;
if (mouseState.up) buttonMask |= 8;
if (mouseState.down) buttonMask |= 16;
// Send message
tunnel.sendMessage("mouse", Math.floor(x), Math.floor(y), buttonMask);
};
/**
* Sends a touch event having the properties provided by the given touch
* state.
*
* @param {Guacamole.Touch.State} touchState
* The state of the touch contact to send in the touch event.
*
* @param {Boolean} [applyDisplayScale=false]
* Whether the provided touch state uses local display units, rather
* than remote display units, and should be scaled to match the
* {@link Guacamole.Display}.
*/
this.sendTouchState = function sendTouchState(touchState, applyDisplayScale) {
// Do not send requests if not connected
if (!isConnected())
return;
var x = touchState.x;
var y = touchState.y;
// Translate for display units if requested
if (applyDisplayScale) {
x /= display.getScale();
y /= display.getScale();
}
tunnel.sendMessage('touch', touchState.id, Math.floor(x), Math.floor(y),
Math.floor(touchState.radiusX), Math.floor(touchState.radiusY),
touchState.angle, touchState.force);
};
/**
* Allocates an available stream index and creates a new
* Guacamole.OutputStream using that index, associating the resulting
* stream with this Guacamole.Client. Note that this stream will not yet
* exist as far as the other end of the Guacamole connection is concerned.
* Streams exist within the Guacamole protocol only when referenced by an
* instruction which creates the stream, such as a "clipboard", "file", or
* "pipe" instruction.
*
* @returns {!Guacamole.OutputStream}
* A new Guacamole.OutputStream with a newly-allocated index and
* associated with this Guacamole.Client.
*/
this.createOutputStream = function createOutputStream() {
// Allocate index
var index = stream_indices.next();
// Return new stream
var stream = output_streams[index] = new Guacamole.OutputStream(guac_client, index);
return stream;
};
/**
* Opens a new audio stream for writing, where audio data having the give
* mimetype will be sent along the returned stream. The instruction
* necessary to create this stream will automatically be sent.
*
* @param {String} mimetype
* The mimetype of the audio data that will be sent along the returned
* stream.
*
* @return {!Guacamole.OutputStream}
* The created audio stream.
*/
this.createAudioStream = function(mimetype) {
// Allocate and associate stream with audio metadata
var stream = guac_client.createOutputStream();
tunnel.sendMessage("audio", stream.index, mimetype);
return stream;
};
/**
* Opens a new file for writing, having the given index, mimetype and
* filename. The instruction necessary to create this stream will
* automatically be sent.
*
* @param {String} mimetype The mimetype of the file being sent.
* @param {String} filename The filename of the file being sent.
* @return {!Guacamole.OutputStream} The created file stream.
*/
this.createFileStream = function(mimetype, filename) {
// Allocate and associate stream with file metadata
var stream = guac_client.createOutputStream();
tunnel.sendMessage("file", stream.index, mimetype, filename);
return stream;
};
/**
* Opens a new pipe for writing, having the given name and mimetype. The
* instruction necessary to create this stream will automatically be sent.
*
* @param {String} mimetype The mimetype of the data being sent.
* @param {String} name The name of the pipe.
* @return {!Guacamole.OutputStream} The created file stream.
*/
this.createPipeStream = function(mimetype, name) {
// Allocate and associate stream with pipe metadata
var stream = guac_client.createOutputStream();
tunnel.sendMessage("pipe", stream.index, mimetype, name);
return stream;
};
/**
* Opens a new clipboard object for writing, having the given mimetype. The
* instruction necessary to create this stream will automatically be sent.
*
* @param {String} mimetype The mimetype of the data being sent.
* @param {String} name The name of the pipe.
* @return {!Guacamole.OutputStream} The created file stream.
*/
this.createClipboardStream = function(mimetype) {
// Allocate and associate stream with clipboard metadata
var stream = guac_client.createOutputStream();
tunnel.sendMessage("clipboard", stream.index, mimetype);
return stream;
};
/**
* Opens a new argument value stream for writing, having the given
* parameter name and mimetype, requesting that the connection parameter
* with the given name be updated to the value described by the contents
* of the following stream. The instruction necessary to create this stream
* will automatically be sent.
*
* @param {String} mimetype
* The mimetype of the data being sent.
*
* @param {String} name
* The name of the connection parameter to attempt to update.
*
* @return {Guacamole.OutputStream}
* The created argument value stream.
*/
this.createArgumentValueStream = function createArgumentValueStream(mimetype, name) {
// Allocate and associate stream with argument value metadata
var stream = guac_client.createOutputStream();
tunnel.sendMessage("argv", stream.index, mimetype, name);
return stream;
};
/**
* Creates a new output stream associated with the given object and having
* the given mimetype and name. The legality of a mimetype and name is
* dictated by the object itself. The instruction necessary to create this
* stream will automatically be sent.
*
* @param {Number} index
* The index of the object for which the output stream is being
* created.
*
* @param {String} mimetype
* The mimetype of the data which will be sent to the output stream.
*
* @param {String} name
* The defined name of an output stream within the given object.
*
* @returns {!Guacamole.OutputStream}
* An output stream which will write blobs to the named output stream
* of the given object.
*/
this.createObjectOutputStream = function createObjectOutputStream(index, mimetype, name) {
// Allocate and ssociate stream with object metadata
var stream = guac_client.createOutputStream();
tunnel.sendMessage("put", index, stream.index, mimetype, name);
return stream;
};
/**
* Requests read access to the input stream having the given name. If
share/public/guaclite.js view on Meta::CPAN
* used.
*/
this.onaudio = null;
/**
* Fired when a video stream is created. The stream provided to this event
* handler will contain its own event handlers for received data.
*
* @event
* @param {Guacamole.InputStream} stream
* The stream that will receive video data from the server.
*
* @param {Guacamole.Display.VisibleLayer} layer
* The destination layer on which the received video data should be
* played. It is the responsibility of the Guacamole.VideoPlayer
* implementation to play the received data within this layer.
*
* @param {String} mimetype
* The mimetype of the video data which will be received.
*
* @return {Guacamole.VideoPlayer}
* An object which implements the Guacamole.VideoPlayer interface and
* has been initialied to play the data in the provided stream, or null
* if the built-in video players of the Guacamole client should be
* used.
*/
this.onvideo = null;
/**
* Fired when the remote client is explicitly declaring the level of
* multi-touch support provided by a particular display layer.
*
* @event
* @param {Guacamole.Display.VisibleLayer} layer
* The layer whose multi-touch support level is being declared.
*
* @param {Number} touches
* The maximum number of simultaneous touches supported by the given
* layer, where 0 indicates that touch events are not supported at all.
*/
this.onmultitouch = null;
/**
* Fired when the current value of a connection parameter is being exposed
* by the server.
*
* @event
* @param {Guacamole.InputStream} stream
* The stream that will receive connection parameter data from the
* server.
*
* @param {String} mimetype
* The mimetype of the data which will be received.
*
* @param {String} name
* The name of the connection parameter whose value is being exposed.
*/
this.onargv = null;
/**
* Fired when the clipboard of the remote client is changing.
*
* @event
* @param {Guacamole.InputStream} stream The stream that will receive
* clipboard data from the server.
* @param {String} mimetype The mimetype of the data which will be received.
*/
this.onclipboard = null;
/**
* Fired when a file stream is created. The stream provided to this event
* handler will contain its own event handlers for received data.
*
* @event
* @param {Guacamole.InputStream} stream The stream that will receive data
* from the server.
* @param {String} mimetype The mimetype of the file received.
* @param {String} filename The name of the file received.
*/
this.onfile = null;
/**
* Fired when a filesystem object is created. The object provided to this
* event handler will contain its own event handlers and functions for
* requesting and handling data.
*
* @event
* @param {Guacamole.Object} object
* The created filesystem object.
*
* @param {String} name
* The name of the filesystem.
*/
this.onfilesystem = null;
/**
* Fired when a pipe stream is created. The stream provided to this event
* handler will contain its own event handlers for received data;
*
* @event
* @param {Guacamole.InputStream} stream The stream that will receive data
* from the server.
* @param {String} mimetype The mimetype of the data which will be received.
* @param {String} name The name of the pipe.
*/
this.onpipe = null;
/**
* Fired when a "required" instruction is received. A required instruction
* indicates that additional parameters are required for the connection to
* continue, such as user credentials.
*
* @event
* @param {String[]} parameters
* The names of the connection parameters that are required to be
* provided for the connection to continue.
*/
this.onrequired = null;
/**
* Fired whenever a sync instruction is received from the server, indicating
* that the server is finished processing any input from the client and
* has sent any results.
*
* @event
* @param {Number} timestamp The timestamp associated with the sync
* instruction.
*/
share/public/guaclite.js view on Meta::CPAN
},
"blob": function(parameters) {
// Get stream
var stream_index = parseInt(parameters[0]);
var data = parameters[1];
var stream = streams[stream_index];
// Write data
if (stream && stream.onblob)
stream.onblob(data);
},
"body" : function handleBody(parameters) {
// Get object
var objectIndex = parseInt(parameters[0]);
var object = objects[objectIndex];
var streamIndex = parseInt(parameters[1]);
var mimetype = parameters[2];
var name = parameters[3];
// Create stream if handler defined
if (object && object.onbody) {
var stream = streams[streamIndex] = new Guacamole.InputStream(guac_client, streamIndex);
object.onbody(stream, mimetype, name);
}
// Otherwise, unsupported
else
guac_client.sendAck(streamIndex, "Receipt of body unsupported", 0x0100);
},
"cfill": function(parameters) {
var channelMask = parseInt(parameters[0]);
var layer = getLayer(parseInt(parameters[1]));
var r = parseInt(parameters[2]);
var g = parseInt(parameters[3]);
var b = parseInt(parameters[4]);
var a = parseInt(parameters[5]);
display.setChannelMask(layer, channelMask);
display.fillColor(layer, r, g, b, a);
},
"clip": function(parameters) {
var layer = getLayer(parseInt(parameters[0]));
display.clip(layer);
},
"clipboard": function(parameters) {
var stream_index = parseInt(parameters[0]);
var mimetype = parameters[1];
// Create stream
if (guac_client.onclipboard) {
var stream = streams[stream_index] = new Guacamole.InputStream(guac_client, stream_index);
guac_client.onclipboard(stream, mimetype);
}
// Otherwise, unsupported
else
guac_client.sendAck(stream_index, "Clipboard unsupported", 0x0100);
},
"close": function(parameters) {
var layer = getLayer(parseInt(parameters[0]));
display.close(layer);
},
"copy": function(parameters) {
var srcL = getLayer(parseInt(parameters[0]));
var srcX = parseInt(parameters[1]);
var srcY = parseInt(parameters[2]);
var srcWidth = parseInt(parameters[3]);
var srcHeight = parseInt(parameters[4]);
var channelMask = parseInt(parameters[5]);
var dstL = getLayer(parseInt(parameters[6]));
var dstX = parseInt(parameters[7]);
var dstY = parseInt(parameters[8]);
display.setChannelMask(dstL, channelMask);
display.copy(srcL, srcX, srcY, srcWidth, srcHeight,
dstL, dstX, dstY);
},
"cstroke": function(parameters) {
var channelMask = parseInt(parameters[0]);
var layer = getLayer(parseInt(parameters[1]));
var cap = lineCap[parseInt(parameters[2])];
var join = lineJoin[parseInt(parameters[3])];
var thickness = parseInt(parameters[4]);
var r = parseInt(parameters[5]);
var g = parseInt(parameters[6]);
var b = parseInt(parameters[7]);
var a = parseInt(parameters[8]);
display.setChannelMask(layer, channelMask);
display.strokeColor(layer, cap, join, thickness, r, g, b, a);
},
"cursor": function(parameters) {
var cursorHotspotX = parseInt(parameters[0]);
var cursorHotspotY = parseInt(parameters[1]);
var srcL = getLayer(parseInt(parameters[2]));
var srcX = parseInt(parameters[3]);
var srcY = parseInt(parameters[4]);
var srcWidth = parseInt(parameters[5]);
var srcHeight = parseInt(parameters[6]);
( run in 2.431 seconds using v1.01-cache-2.11-cpan-2398b32b56e )