bfg-common 1.0.0

package/public/spice-console/process/busprocess.js

@@ -0,0 +1,309 @@
+/*
+    Copyright (c) 2016 eyeOS
+
+    This file is part of Open365.
+
+    Open365 is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program 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.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+wdi.BUS_TYPES = {
+	file: 0,  // obsolete
+	print: 1, // obsolete
+	launchApplication: 2,
+	windowManagement: 3,
+	menu: 5,
+	networkDriveManagement: 6,
+	clipboard: 9,
+
+	// This is for those messages that doesn't fit in any of
+	// the previous types and doesn't deserve its own type.
+	generic: 99,
+
+
+	// Messages used during developing (for benchmarks and whatever).
+	// you should not use them in code for production purposes.
+	killApplicationDoNotUseInProductionEver: 34423423
+};
+
+wdi.BusProcess = $.spcExtend(wdi.EventObject.prototype, {
+	busConnection: null,
+	clientGui: null,
+
+	init: function(c) {
+		this.superInit();
+		this.clientGui = c.clientGui;
+		this.busConnection = c.busConnection;
+	},
+
+	dispose: function () {
+		this.clientGui = null;
+		this.busConnection = null;
+	},
+
+	process: function(message) {
+		switch(message['verb']) {
+			case "CONNECTED":
+				this.busConnection.setSubscriptions();
+				this.fire('busConnected');
+				break;
+			case "MESSAGE":
+				this.parseMessage(message['body']);
+				break;
+			case "ERROR":
+				console.error("Bus error");
+				break;
+			default:
+				wdi.Debug.warn("Not implemented Stomp Verb: " + message['verb']);
+		}
+	},
+
+	parseMessage: function(body) {
+		switch(parseInt(body['type'])) {
+			case wdi.BUS_TYPES.launchApplication:
+				this.parseLaunchApplicationMessage(body);
+				break;
+			case wdi.BUS_TYPES.killApplicationDoNotUseInProductionEver:
+				// this is a message we send to the other side of the bus
+				// so do nothing.
+				break;
+			case wdi.BUS_TYPES.windowManagement:
+				this.parseWindowManagementMessage(body);
+				break;
+			case wdi.BUS_TYPES.menu:
+				this.handleMenuMessage(body);
+				break;
+			case wdi.BUS_TYPES.networkDriveManagement:
+				this._handleNetworkDriveMessage(body);
+				break;
+			case wdi.BUS_TYPES.clipboard:
+				this.handleClipboardMessage(body);
+				break;
+			default:
+				this.fire('defaultTypeEvent', body);
+				break;
+		}
+	},
+
+	_handleNetworkDriveMessage : function(message) {
+		if(message.event != 'reMountNetworkDrive') {
+			this.fire('networkDriveResponse', message);
+		}
+	},
+
+	getMenu: function() {
+		this.busConnection.send(
+			{
+				"type": wdi.BUS_TYPES.menu,
+				"value": false,
+				"event": 'request'
+			}
+		)
+	},
+
+	handleMenuMessage: function(message) {
+		if(message.event == 'response') {
+			this.fire('menuResponse', message);
+		}
+	},
+	handleClipboardMessage: function(message) {
+		if(message.event === 'selectedText' || message.event === 'copiedText') {
+			this.fire(message.event, message);
+		}
+	},
+
+	parseWindowManagementMessage: function(message) {
+		switch (message['event']) {
+			case 'windowList':
+			case 'windowCreated':
+			case 'windowClosed':
+			case 'windowMoved':
+			case 'windowResized':
+			case 'windowFocused':
+			case 'windowMinimized':
+			case 'windowRestored':
+			case 'windowMaximized':
+				this.fire(message['event'], message['value']);
+				break;
+			default:
+				wdi.Debug.info("Event '" + message['event'] + "' not implemented.")
+		}
+	},
+
+	closeWindow: function(hwnd) {
+		this.busConnection.send(
+			this._constructWindowManagementMessage(
+				{
+					"event": 'closeWindow',
+					"hwnd": hwnd
+				}
+			)
+		);
+	},
+
+	moveWindow: function(hwnd, x, y) {
+		this.busConnection.send(
+			this._constructWindowManagementMessage(
+				{
+					"event": 'moveWindow',
+					"hwnd": hwnd,
+					"left": x,
+					"top": y
+				}
+			)
+		);
+	},
+
+	minimizeWindow: function(hwnd) {
+		this.busConnection.send(
+			this._constructWindowManagementMessage(
+				{
+					"event": 'minimizeWindow',
+					"hwnd": hwnd
+				}
+			)
+		);
+	},
+
+	maximizeWindow: function(hwnd) {
+		this.busConnection.send(
+			this._constructWindowManagementMessage(
+				{
+					"event": 'maximizeWindow',
+					"hwnd": hwnd
+				}
+			)
+		);
+	},
+
+	restoreWindow: function(hwnd) {
+		this.busConnection.send(
+			this._constructWindowManagementMessage(
+				{
+					"event": 'restoreWindow',
+					"hwnd": hwnd
+				}
+			)
+		);
+	},
+
+	focusWindow: function(hwnd) {
+		this.busConnection.send(
+			this._constructWindowManagementMessage(
+				{
+					"event": 'focusWindow',
+					"hwnd": hwnd
+				}
+			)
+		);
+	},
+
+	resizeWindow: function(hwnd, width, height) {
+		this.busConnection.send(
+			this._constructWindowManagementMessage(
+				{
+					"event": 'resizeWindow',
+					"hwnd": hwnd,
+					"width": width,
+					"height": height
+				}
+			)
+		);
+	},
+
+	requestWindowList: function() {
+		this.busConnection.send(
+			this._constructWindowManagementMessage(
+				{
+					"event": 'getWindowList'
+				}
+			)
+		)
+	},
+
+	executeCommand: function(cmd) {
+		this.busConnection.send(
+			{
+				"type": wdi.BUS_TYPES.launchApplication,
+				"application": cmd
+			}
+		)
+
+	},
+
+	refreshFileSystem: function(data) {
+		this.busConnection.send(
+			{
+				'type': wdi.BUS_TYPES.file,
+				'event': "refreshFileSystem",
+				'value': {}
+			}
+		)
+	},
+
+	_constructGenericMessage: function (eventName, data) {
+		return {
+			'type': wdi.BUS_TYPES.generic,
+			'event': eventName,
+			'value': data || {}
+		};
+	},
+
+	_constructWindowManagementMessage: function(obj) {
+		if (obj['event'] === undefined) {
+			throw new Error("You should pass an 'event' attribute in the object");
+		}
+		var ret = {
+			'type': wdi.BUS_TYPES.windowManagement,
+			'event': obj['event'],
+			'value': {}
+		};
+		for (var i in obj) {
+			if (i != 'event' && obj.hasOwnProperty(i)) {
+				ret['value'][i] = obj[i];
+			}
+		}
+		return ret;
+	},
+
+	reMountNetworkDrive: function(host, username, password) {
+		this.busConnection.send(
+			{
+				"type": wdi.BUS_TYPES.networkDriveManagement,
+				"event": "reMountNetworkDrive",
+				"host": host,
+				"username": username,
+				"password": password
+			}
+		)
+	},
+
+	parseLaunchApplicationMessage: function (message) {
+		switch (message['event']) {
+			case 'applicationLauncherWrongAppPathError':
+				this.fire('wrongPathError', message);
+				break;
+			case 'applicationLaunchedSuccessfully':
+				this.fire('applicationLaunchedSuccessfully', message);
+				break;
+			default:
+				wdi.Debug.info("Event '" + message['event'] + "' not implemented.")
+		}
+	},
+
+	sendGenericMessage: function (eventName, data) {
+		this.busConnection.send(
+			this._constructGenericMessage(eventName, data)
+		);
+	}
+});

package/public/spice-console/process/cursorprocess.js

@@ -0,0 +1,110 @@
+/*
+    Copyright (c) 2016 eyeOS
+
+    This file is part of Open365.
+
+    Open365 is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program 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.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+wdi.CursorProcess = $.spcExtend(wdi.EventObject.prototype, {
+	imageData: null,
+	
+	process: function(spiceMessage) {
+		switch (spiceMessage.messageType) {
+			case wdi.SpiceVars.SPICE_MSG_CURSOR_INIT:
+			case wdi.SpiceVars.SPICE_MSG_CURSOR_SET:
+				var wdiCursor = this.extractCursor(spiceMessage);
+				if(wdiCursor) {
+					wdi.VirtualMouse.setHotspot(0, 0);
+					wdi.VirtualMouse.setMouse(wdiCursor.data, wdiCursor.header.hot_spot_x, wdiCursor.header.hot_spot_y);
+				}
+				break;
+			case wdi.SpiceVars.SPICE_MSG_CURSOR_HIDE:
+				wdi.VirtualMouse.hideMouse();
+				break;
+		}
+	},
+
+	dispose: function() {
+		this.clearEvents();
+		this.imageData = null;
+	},
+
+	_toUrl:function(data) {
+		var imageData = $('<canvas/>').attr({
+			'width': data.width,
+			'height': data.height
+		})[0];
+		var ctx = imageData.getContext('2d');
+		ctx.putImageData(data, 0, 0);
+		return imageData.toDataURL("image/png");
+	},
+	
+	extractCursor: function(spiceMessage) {
+		var flags = spiceMessage.args.cursor.flags;
+		var position = spiceMessage.args.position;
+		var visible = spiceMessage.args.visible;
+		
+		//if there is no cursor, return null
+		if(flags & 1) {
+			return null;
+		}
+	
+		var imageData = null;
+		
+		//cursor from cache?
+		if(flags & wdi.SpiceCursorFlags.SPICE_CURSOR_FLAGS_FROM_CACHE) {
+			imageData = wdi.ImageCache.getCursorFrom(spiceMessage.args.cursor);			
+		} else {
+			//cursor from packet
+			//any case should return url
+			switch (spiceMessage.args.cursor.header.type) {
+
+				case wdi.SpiceCursorType.SPICE_CURSOR_TYPE_ALPHA:
+					imageData = this._toUrl(wdi.graphics.argbToImageData(spiceMessage.args.cursor.data, spiceMessage.args.cursor.header.width, spiceMessage.args.cursor.header.height));
+					break;
+				case wdi.SpiceCursorType.SPICE_CURSOR_TYPE_MONO:
+					imageData = this._toUrl(wdi.graphics.monoToImageData(spiceMessage.args.cursor.data, spiceMessage.args.cursor.header.width, spiceMessage.args.cursor.header.height));
+					break;
+				case 8:
+					imageData = wdi.SpiceObject.bytesToString(spiceMessage.args.cursor.data);
+					break;
+				case wdi.SpiceCursorType.SPICE_CURSOR_TYPE_COLOR4:
+				case wdi.SpiceCursorType.SPICE_CURSOR_TYPE_COLOR8:
+				case wdi.SpiceCursorType.SPICE_CURSOR_TYPE_COLOR16:
+				case wdi.SpiceCursorType.SPICE_CURSOR_TYPE_COLOR24:
+				case wdi.SpiceCursorType.SPICE_CURSOR_TYPE_COLOR32:
+				case wdi.SpiceCursorType.SPICE_CURSOR_TYPE_ENUM_END:
+					break;
+			}	
+		}
+	
+		//got no cursor? error!
+		if(!imageData) {
+			return null;
+		}
+	
+		//we have cursor, cache it?
+		if(flags & wdi.SpiceCursorFlags.SPICE_CURSOR_FLAGS_CACHE_ME) {
+			wdi.ImageCache.addCursor(spiceMessage.args.cursor, imageData);
+		}
+		
+		return {
+			data: imageData, 
+			position: position, 
+			visible: visible,
+			header: spiceMessage.args.cursor.header
+		};
+	}
+});

package/public/spice-console/process/displaypreprocess.js

@@ -0,0 +1,152 @@
+/*
+    Copyright (c) 2016 eyeOS
+
+    This file is part of Open365.
+
+    Open365 is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program 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.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+wdi.DisplayPreProcess = $.spcExtend(wdi.EventObject.prototype, {
+	displayProcess: null,
+	queued: [],
+	inProcess: [],
+	idleConsumers : [],
+	consumers: [],
+
+	init: function(c) {
+		this.idleConsumers = [];
+		this.superInit();
+		this.displayProcess = c.displayProcess || new wdi.DisplayProcess({
+				clientGui: c.clientGui,
+				disableMessageBuffering: c.disableMessageBuffering
+		});
+		this.clientGui = c.clientGui;
+
+		/**
+
+		Since javascript do not provide an API to check
+		the number of cpu cores available, the best case for average computers
+		and devices is 4.
+
+		If the computer doesn't have 4 or more available cores, there is only a little
+		memory waste creating the threads and a bit of cpu overheat doing context
+		switching.
+
+		There is an ongoing draft in w3c to standarize a way to detect this:
+
+		http://www.w3.org/2012/sysapps/device-capabilities/#cpu
+
+		**/
+		if(c.numConsumers == null || c.numConsumers == undefined) c.numConsumers = 4;
+		var numConsumers = c.numConsumers;
+
+		for(var i = 0;i<numConsumers; i++) {
+			var consumer = new wdi.AsyncConsumer();
+			this.consumers.push(consumer);
+			this.idleConsumers.push(consumer);
+			consumer.addListener('done', this.onConsumerDone, this);
+		}
+	},
+
+	onConsumerDone: function(e) {
+		//we don't care about who has finished, only about the
+		//state of the last item in queue
+		var waitingTask = this.inProcess[0];
+		var task = null;
+		var i = 0;
+
+		while(waitingTask && waitingTask.state === 1) {
+			task = this.inProcess.shift();
+			try {
+				this.displayProcess.process(task.message);
+			} catch(e) {
+				wdi.Debug.error("DisplayPreProcess error: ", e);
+			}
+			waitingTask = this.inProcess[0];
+			i++;
+		}
+
+		//put the consumer as idle
+		this.idleConsumers.push(e);
+		//continue processing!
+		if(this.queued.length > 0) {
+			this.executeConsumer();
+		}
+	},
+
+	process: function(spiceMessage) {
+		this.addTask(spiceMessage); //first of all, queue it
+		//it is the only item in the list?
+		//we are the only message in the queue... process?
+		this.executeConsumer();
+	},
+
+	addTask: function(spiceMessage) {
+		this.queued.push({
+			message: spiceMessage,
+			clientGui: this.clientGui
+		});
+	},
+
+	getNextTask : function () {
+		var task = this.queued.shift();
+		while(typeof task == 'undefined' && this.queued.length != 0) {
+			task = this.queued.shift();
+		}
+
+		//we found a task?
+		if(typeof task == 'undefined') {
+			return false;
+		}
+
+		task.state = 0;
+		this.inProcess.push(task); //add the task to the inProcess list
+		return task;
+	},
+
+	executeConsumer: function() {
+		//check if there are idle consumers
+		if(this.idleConsumers.length > 0) {
+			wdi.Debug.log('DisplayPreProcess: available workers: '+this.idleConsumers.length);
+			wdi.Debug.log('DisplaypreProcess: pending tasks: '+this.queued.length);
+			//idle consumer found
+			var consumer = this.idleConsumers.shift();
+			//execute the next task in this consumer
+			var task = this.getNextTask();
+
+			if(task) {
+				consumer.consume(task);
+			}
+
+		}
+	},
+
+	dispose: function () {
+		wdi.Debug.log('displaypreprocess dispose ################ idleConsumers: ', this.idleConsumers.length);
+		this.clearEvents();
+		this.clientGui = null;
+		this.queued = [];
+		this.inProcess = [];
+		this.idleConsumers = [];
+
+		this.displayProcess.dispose();
+		this.displayProcess = null;
+		this.consumers.forEach(function (consumer) {
+			consumer.clearEvents();
+			consumer.dispose();
+		});
+
+		this.consumers = [];
+	}
+});