☰

Greasy Fork is available in English.

wLib test

A WME developers library

Questo script non dovrebbe essere installato direttamente. È una libreria per altri script da includere con la chiave // @require https://update.greatest.deepsurf.us/scripts/23207/147386/wLib%20test.js 

  1. // ==UserScript==
  2. // @name            wLib test
  3. // @description     A WME developers library
  4. // @version         0.1a
  5. // @author          SAR85,tm
  6. // @copyright       SAR85
  7. // @license         CC BY-NC-ND
  8. // @grant           none
  9. // @include         https://www.waze.com/editor/*
  10. // @include         https://www.waze.com/*/editor/*
  11. // @include         https://beta.waze.com/*
  12. // @exclude         https://www.waze.com/user/*
  13. // ==/UserScript==
  14.  
  15. (function () {
  16. 	/**
  17. 	* The wLib namespace.
  18. 	* @namespace
  19. 	* @global
  20. 	*/
  21. 	this.wLib = {VERSION: '0.1'};
  22. }).call(this);
  23.  
  24. (function () {
  25. 	/*** GEOMETRY ***/
  26. 	/**
  27. 	* Namespace for functions related to geometry.
  28. 	* @memberof wLib
  29. 	* @namespace
  30. 	* @name wLib.Geometry
  31. 	*/
  32. 	this.Geometry = {
  33. 		/**
  34. 		* Determines if an {OpenLayers.Geometry} is within the map view.
  35. 		* @memberof wLib.Geometry
  36. 		* @param geometry {OpenLayers.Geometry}
  37. 		* @return {Boolean} Whether or not the geometry is in the map extent.
  38. 		*/
  39. 		isGeometryInMapExtent: function (geometry) {
  40. 			'use strict';
  41. 			return geometry && geometry.getBounds &&
  42. 			W.map.getExtent().intersectsBounds(geometry.getBounds())
  43. 		},
  44. 		/**
  45. 		 * Determines if an {OpenLayers.LonLat} is within the map view.
  46. 		 * @memberof wLib.Geometry
  47. 		 * @param {OpenLayers.LonLat} lonlat
  48. 		 * @return {Boolean} Whether or not the LonLat is in the map extent.
  49. 		 */
  50. 		isLonLatInMapExtent: function (lonlat) {
  51. 			'use strict';
  52. 			return lonlat && W.map.getExtent().containsLonLat(lonlat);
  53. 		}
  54. 	};
  55. }).call(wLib);
  56.  
  57. (function() {
  58. 	/*** MODEL ***/
  59. 	/**
  60. 	* Namespace for functions related to the model.
  61. 	* @memberof wLib
  62. 	* @namespace
  63. 	* @name wLib.Model
  64. 	*/
  65. 	this.Model = {};
  66. 	
  67. 	/**
  68. 	* Gets the IDs of any selected segments.
  69. 	* @memberof wLib.Model
  70. 	* @return {Array} Array containing the IDs of selected segments.
  71. 	*/
  72. 	this.Model.getSelectedSegmentIDs = function () {
  73. 		'use strict';
  74. 		var i, n, selectedItems, item, segments = [];
  75. 		if (!W.selectionManager.hasSelectedItems()) {
  76. 			return false;
  77. 		} else {
  78. 			selectedItems = W.selectionManager.selectedItems;
  79. 			for (i = 0, n = selectedItems.length; i < n; i++) {
  80. 				item = selectedItems[i].model;
  81. 				if ('segment' === item.type) {
  82. 					segments.push(item.attributes.id);
  83. 				}
  84. 			}
  85. 			return segments.length === 0 ? false : segments;
  86. 		}
  87. 	};	
  88. 	
  89. 	/**
  90. 	 * Retrieves a route from the Waze Live Map.
  91. 	 * @class
  92. 	 * @name wLib.Model.RouteSelection
  93. 	 * @param firstSegment The segment to use as the start of the route.
  94. 	 * @param lastSegment The segment to use as the destination for the route.
  95. 	 * @param {Array|Function} callback A function or array of functions to be executed after the route
  96. 	 * is retrieved. 'This' in the callback functions will refer to the RouteSelection object.
  97. 	 * @param {Object} options A hash of options for determining route. Valid options are:
  98. 	 * fastest: {Boolean} Whether or not the fastest route should be used. Default is false,
  99. 	 * which selects the shortest route.
  100. 	 * freeways: {Boolean} Whether or not to avoid freeways. Default is false.
  101. 	 * dirt: {Boolean} Whether or not to avoid dirt roads. Default is false.
  102. 	 * longtrails: {Boolean} Whether or not to avoid long dirt roads. Default is false.
  103. 	 * uturns: {Boolean} Whether or not to allow U-turns. Default is true.
  104. 	 * @return {wLib.Model.RouteSelection} The new RouteSelection object.
  105. 	 * @example: // The following example will retrieve a route from the Live Map and select the segments in the route.
  106. 	 * selection = W.selectionManager.selectedItems;
  107. 	 * myRoute = new wLib.Model.RouteSelection(selection[0], selection[1], function(){this.selectRouteSegments();}, {fastest: true});
  108. 	 */
  109. 	this.Model.RouteSelection = function (firstSegment, lastSegment, callback, options) {
  110. 	    var i,
  111. 			n,
  112. 			start = this.getSegmentCenterLonLat(firstSegment),
  113. 			end = this.getSegmentCenterLonLat(lastSegment);
  114. 	    this.options = {
  115. 	        fastest: options && options.fastest || false,
  116. 	        freeways: options && options.freeways || false,
  117. 	        dirt: options && options.dirt || false,
  118. 			longtrails: options && options.longtrails || false,
  119. 	        uturns: options && options.uturns || true
  120. 	    };
  121. 	    this.requestData = {
  122. 	        from: 'x:' + start.x + ' y:' + start.y + ' bd:true',
  123. 	        to: 'x:' + end.x + ' y:' + end.y + ' bd:true',
  124. 	        returnJSON: true,
  125. 	        returnGeometries: true,
  126. 	        returnInstructions: false,
  127. 	        type: this.options.fastest ? 'HISTORIC_TIME' : 'DISTANCE',
  128. 	        clientVersion: '4.0.0',
  129. 	        timeout: 60000,
  130. 	        nPaths: 3,
  131. 	        options: this.setRequestOptions(this.options)
  132. 	    };
  133. 		this.callbacks = [];
  134. 		if (callback) {
  135. 			if (!(callback instanceof Array)) {
  136. 				callback = [callback];
  137. 			}
  138. 			for (i = 0, n = callback.length; i < n; i++) {
  139. 				if ('function' === typeof callback[i]) {
  140. 					this.callbacks.push(callback[i])
  141. 				}
  142. 			}
  143. 		}
  144. 	    this.routeData = null;
  145. 		this.getRouteData();
  146. 		return this;
  147. 	};
  148. 	this.Model.RouteSelection.prototype = /** @lends wLib.Model.RouteSelection.prototype */ {
  149. 		/**
  150. 		 * Formats the routing options string for the ajax request.
  151. 		 * @private
  152. 		 * @param {Object} options Object containing the routing options.
  153. 		 * @return {String} String containing routing options.
  154. 		 */
  155. 	    setRequestOptions: function (options) {
  156. 	        return 'AVOID_TOLL_ROADS:' + (options.tolls ? 't' : 'f') + ',' +
  157. 	      		'AVOID_PRIMARIES:' + (options.freeways ? 't' : 'f') + ',' +
  158. 	      		'AVOID_TRAILS:' + (options.dirt ? 't' : 'f') + ',' +
  159. 				'AVOID_LONG_TRAILS:' + (options.longtrails ? 't' : 'f') + ',' +
  160. 	      		'ALLOW_UTURNS:' + (options.uturns ? 't' : 'f');
  161. 	    },
  162. 		/**
  163. 		 * Gets the center of a segment in LonLat form.
  164. 		 * @private
  165. 		 * @param segment A Waze model segment object.
  166. 		 * @return {OpenLayers.LonLat} The LonLat object corresponding to the
  167. 		 * center of the segment.
  168. 		 */
  169. 	    getSegmentCenterLonLat: function (segment) {
  170. 			var x, y, componentsLength, midPoint;
  171. 			if (segment) {
  172. 				componentsLength = segment.geometry.components.length;
  173. 				midPoint = Math.floor( componentsLength / 2);
  174. 				if (componentsLength % 2 === 1) {
  175. 					x = segment.geometry.components[midPoint].x;
  176. 					y = segment.geometry.components[midPoint].y;
  177. 				} else {
  178. 					x = (segment.geometry.components[midPoint - 1].x +
  179. 						segment.geometry.components[midPoint].x) / 2;
  180. 					y = (segment.geometry.components[midPoint - 1].y +
  181. 						segment.geometry.components[midPoint].y) / 2;
  182. 				}
  183. 				return new OL.Geometry.Point(x, y).transform(W.map.getProjectionObject(), 'EPSG:4326');
  184. 			}
  185. 	        
  186. 	    },
  187. 		/**
  188. 		 * Gets the route from Live Map and executes any callbacks upon success.
  189. 		 * @private
  190. 		 * @returns The ajax request object. The responseJSON property of the returned object
  191. 		 * contains the route information.
  192. 		 * 
  193. 		 */
  194. 	    getRouteData: function () {
  195. 			var i,
  196. 				n,
  197. 				that = this;
  198. 	        return $.ajax({
  199. 	            dataType: "json",
  200. 	            url: this.getURL(),
  201. 	            data: this.requestData,
  202. 	            dataFilter: function (data, dataType) {
  203. 	                return data.replace(/NaN/g, '0');
  204. 	            },
  205. 				success: function(data) {
  206. 					that.routeData = data;
  207. 					for (i = 0, n = that.callbacks.length; i < n; i++) {
  208. 						that.callbacks[i].call(that);
  209. 					}
  210. 				}
  211. 	        });
  212. 	    },
  213. 		/**
  214. 		 * Extracts the IDs from all segments on the route.
  215. 		 * @private
  216. 		 * @return {Array} Array containing an array of segment IDs for
  217. 		 * each route alternative.
  218. 		 */
  219. 	    getRouteSegmentIDs: function () {
  220. 	        var i, j, route, len1, len2, segIDs = [], 
  221. 	            routeArray = [],
  222. 	            data = this.routeData;
  223. 	        if ('undefined' !== typeof data.alternatives) {
  224. 	            for (i = 0 , len1 = data.alternatives.length; i < len1; i++) {
  225. 	                route = data.alternatives[i].response.results;
  226. 	                for (j = 0, len2 = route.length; j < len2; j++) {
  227. 	                    routeArray.push(route[j].path.segmentId);
  228. 	                }
  229. 	                segIDs.push(routeArray);
  230. 	                routeArray = [];
  231. 	            }
  232. 	        } else {
  233. 	            route = data.response.results;
  234. 	            for (i = 0 , len1 = route.length; i < len1; i++) {
  235. 	                routeArray.push(route[i].path.segmentId);
  236. 	            }
  237. 	            segIDs.push(routeArray);
  238. 	        }
  239. 	        return segIDs;
  240. 	    },
  241. 		/**
  242. 		 * Gets the URL to use for the ajax request based on country.
  243. 		 * @private
  244. 		 * @return {String} Relative URl to use for route ajax request.
  245. 		 */
  246. 	    getURL: function () {
  247. 	        if (W.model.countries.get(235) || W.model.countries.get(40)) {
  248. 	            return '/RoutingManager/routingRequest';
  249. 	        } else if (W.model.countries.get(106)) {
  250. 	            return '/il-RoutingManager/routingRequest';
  251. 	        } else {
  252. 	            return '/row-RoutingManager/routingRequest';
  253. 	        }
  254. 	    },
  255. 		/**
  256. 		 * Selects all segments on the route in the editor.
  257. 		 * @param {Integer} routeIndex The index of the alternate route.
  258. 		 * Default route to use is the first one, which is 0.
  259. 		 */
  260. 	    selectRouteSegments: function (routeIndex) {
  261. 	        var i, n, seg,
  262. 				segIDs = this.getRouteSegmentIDs()[Math.floor(routeIndex) || 0],
  263. 	        	segments = [];
  264. 	        if (undefined === typeof segIDs) {
  265. 	            return;
  266. 	        }
  267. 	        for (i = 0, n = segIDs.length; i < n; i++) {
  268. 				seg = W.model.segments.get(segIDs[i])
  269. 	            if (undefined !== seg) {
  270. 					segments.push(seg);
  271. 				}
  272. 	        }
  273. 	        return W.selectionManager.select(segments);
  274. 	    }
  275. 	};
  276. }).call(wLib);
  277.  
  278. (function() {
  279. 	/*** INTERFACE ***/
  280. 	/**
  281. 	* Namespace for functions related to the WME interface
  282. 	* @memberof wLib
  283. 	* @namespace
  284. 	* @name wLib.Interface
  285. 	*/
  286. 	this.Interface = {};
  287.  
  288. 	this.Interface.Shortcut = OL.Class(this.Interface,
  289. 		/** @lends wLib.Interface.Shortcut.prototype */
  290. 		{name: null,
  291. 		group: null,
  292. 		shortcut: {},
  293. 		callback: null,
  294. 		scope: null,
  295. 		groupExists: false,
  296. 		actionExists: false,
  297. 		eventExists: false,
  298. 		/**
  299. 		* Creates a new {wLib.Interface.Shortcut}.
  300. 		* @class
  301. 		* @name wLib.Interface.Shortcut
  302. 		* @param name {String} The name of the shortcut.
  303. 		* @param group {String} The name of the shortcut group.
  304. 		* @param shortcut {String} The shortcut key(s). The shortcut should be of the form
  305. 		* 'i' where i is the keyboard shortuct or include modifier keys such as'CSA+i',
  306. 		* where C = the control key, S = the shift key, A = the alt key, and
  307. 		* i = the desired keyboard shortcut. The modifier keys are optional.
  308. 		* @param callback {Function} The function to be called by the shortcut.
  309. 		* @param scope {Object} The object to be used as this by the callback.
  310. 		* @return {wLib.Interface.Shortcut} The new shortcut object.
  311. 		* @example //Creates new shortcut and adds it to the map.
  312. 		* shortcut = new wLib.Interface.Shortcut('myName', 'myGroup', 'C+p', callbackFunc, null).add();
  313. 		*/
  314. 		initialize: function (name, group, shortcut, callback, scope) {
  315. 			var defaults = {group: 'default'};
  316. 			this.CLASS_NAME = 'wLib Shortcut';
  317. 			if ('string' === typeof name && name.length > 0 &&
  318. 				'string' === typeof shortcut && shortcut.length > 0 &&
  319. 				'function' === typeof callback) {
  320. 				this.name = name;
  321. 				this.group = group || defaults.group;
  322. 				this.callback = callback;
  323. 				this.shortcut[shortcut] = name;
  324. 				if ('object' !== typeof scope) {
  325. 					this.scope = null;
  326. 				} else {
  327. 					this.scope = scope;
  328. 				}
  329. 				return this;
  330. 			}
  331. 		},
  332. 		/**
  333. 		* Determines if the shortcut's group already exists.
  334. 		* @private
  335. 		*/
  336. 		doesGroupExist: function () {
  337. 			this.groupExists = 'undefined' !== typeof W.accelerators.Groups[this.group] &&
  338. 			undefined !== typeof W.accelerators.Groups[this.group].members &&
  339. 			W.accelerators.Groups[this.group].length > 0;
  340. 			return this.groupExists;
  341. 		},
  342. 		/**
  343. 		* Determines if the shortcut's action already exists.
  344. 		* @private
  345. 		*/
  346. 		doesActionExist: function () {
  347. 			this.actionExists = 'undefined' !== typeof W.accelerators.Actions[this.name];
  348. 			return this.actionExists;
  349. 		},
  350. 		/**
  351. 		* Determines if the shortcut's event already exists.
  352. 		* @private
  353. 		*/
  354. 		doesEventExist: function () {
  355. 			this.eventExists = 'undefined' !== typeof W.accelerators.events.listeners[this.name] &&
  356. 				W.accelerators.events.listeners[this.name].length > 0 &&
  357. 				this.callback === W.accelerators.events.listeners[this.name][0].func &&
  358. 				this.scope === W.accelerators.events.listeners[this.name][0].obj;
  359. 			return this.eventExists;
  360. 		},
  361. 		/**
  362. 		* Creates the shortcut's group.
  363. 		* @private
  364. 		*/
  365. 		createGroup: function () {
  366. 			W.accelerators.Groups[this.group] = [];
  367. 			W.accelerators.Groups[this.group].members = [];
  368. 		},
  369. 		/**
  370. 		* Registers the shortcut's action.
  371. 		* @private
  372. 		*/
  373. 		addAction: function () {
  374. 			W.accelerators.addAction(this.name, {group: this.group});
  375. 		},
  376. 		/**
  377. 		* Registers the shortcut's event.
  378. 		* @private
  379. 		*/
  380. 		addEvent: function () {
  381. 			W.accelerators.events.register(this.name, this.scope, this.callback);
  382. 		},
  383. 		/**
  384. 		* Registers the shortcut's keyboard shortcut.
  385. 		* @private
  386. 		*/
  387. 		registerShortcut: function () {
  388. 			W.accelerators.registerShortcuts(this.shortcut);
  389. 		},
  390. 		/**
  391. 		* Adds the keyboard shortcut to the map.
  392. 		* @return {wLib.Interface.Shortcut} The keyboard shortcut.
  393. 		*/
  394. 		add: function () {
  395. 			/* If the group is not already defined, initialize the group. */
  396. 			if (!this.doesGroupExist()) {
  397. 				this.createGroup();
  398. 			}
  399.  
  400. 			/* Clear existing actions with same name */
  401. 			if (this.doesActionExist()) {
  402. 				W.accelerators.Actions[this.name] = null;
  403. 			}
  404. 			this.addAction();
  405.  
  406. 			/* Register event only if it's not already registered */
  407. 			if (!this.doesEventExist()) {
  408. 				this.addEvent();
  409. 			}
  410.  
  411. 			/* Finally, register the shortcut. */
  412. 			this.registerShortcut();
  413. 			return this;
  414. 		},
  415. 		/**
  416. 		* Removes the keyboard shortcut from the map.
  417. 		* @return {wLib.Interface.Shortcut} The keyboard shortcut.
  418. 		*/
  419. 		remove: function () {
  420. 			if (this.doesEventExist()) {
  421. 				W.accelerators.events.unregister(this.name, this.scope, this.callback);
  422. 			}
  423. 			if (this.doesActionExist()) {
  424. 				delete W.accelerators.Actions[this.name];
  425. 			}
  426. 			//remove shortcut?
  427. 			return this;
  428. 		},
  429. 		/**
  430. 		* Changes the keyboard shortcut and applies changes to the map.
  431. 		* @return {wLib.Interface.Shortcut} The keyboard shortcut.
  432. 		*/
  433. 		change: function (shortcut) {
  434. 			if (shortcut) {
  435. 				this.shortcut = {};
  436. 				this.shortcut[shortcut] = this.name;
  437. 				this.registerShortcut();
  438. 			}
  439. 			return this;
  440. 		}
  441. 	});
  442. }).call(wLib);