☰

WazeWrapBeta

A base library for WME script writers

当前为 2018-01-09 提交的版本，查看 最新版本。

此脚本不应直接安装。它是供其他脚本使用的外部库，要使用该库请加入元指令 // @require https://update.gf.qytechs.cn/scripts/24870/242203/WazeWrapBeta.js 

  1. // ==UserScript==
  2. // @name         WazeWrapBeta
  3. // @namespace    https://gf.qytechs.cn/users/30701-justins83-waze
  4. // @version      0.3.07
  5. // @description  A base library for WME script writers
  6. // @author       JustinS83/MapOMatic
  7. // @include      https://beta.waze.com/*editor*
  8. // @include      https://www.waze.com/*editor*
  9. // @exclude      https://www.waze.com/*user/editor/*
  10. // @grant        none
  11. // ==/UserScript==
  12.  
  13. /* global W */
  14. /* global WazeWrap */
  15.  
  16. var WazeWrap = {};
  17.  
  18. (function() {
  19.  
  20. 	function bootstrap(tries) {
  21. 		tries = tries || 1;
  22. 		if (window.W && window.W.map &&
  23. 			window.W.model && window.W.loginManager.user &&
  24. 			$) {
  25. 			init();
  26. 		} else if (tries < 1000) {
  27. 			setTimeout(function () { bootstrap(tries++); }, 200);
  28. 		} else {
  29. 			console.log('WazeWrap failed to load');
  30. 		}
  31. 	}
  32.  
  33.     bootstrap();
  34.  
  35.     function init(){
  36. 		console.log("WazeWrap initializing...");
  37. 		
  38.         var oldLib = window.WazeWrap;
  39.         var root = this;
  40.  
  41. 		WazeWrap.Version = "0.3.07";
  42. 		WazeWrap.isBetaEditor = /beta/.test(location.href);
  43.  
  44. 	    RestoreMissingSegmentFunctions();
  45. 	    
  46. 		WazeWrap.Geometry = new Geometry();
  47. 		WazeWrap.Model = new Model();
  48. 		WazeWrap.Interface = new Interface();
  49. 		WazeWrap.User = new User();
  50. 		WazeWrap.Util = new Util();
  51. 		WazeWrap.Require = new Require();
  52. 	    WazeWrap.String = new String();
  53. 		
  54.         root.WazeWrap = WazeWrap;
  55.  
  56.         console.log('WazeWrap Loaded');
  57.     }
  58.  
  59. 	function RestoreMissingSegmentFunctions(){
  60. 		if(W.model.segments.getObjectArray().length > 0){
  61. 			Waze.map.events.unregister("moveend", this, RestoreMissingSegmentFunctions);
  62. 			Waze.map.events.unregister("zoomend", this, RestoreMissingSegmentFunctions);
  63. 			if(typeof W.model.segments.getObjectArray()[0].model.getDirection == "undefined")
  64. 				W.model.segments.getObjectArray()[0].__proto__.getDirection = function(){return (this.attributes.fwdDirection ? 1 : 0) + (this.attributes.revDirection ? 2 : 0);};
  65. 			if(typeof W.model.segments.getObjectArray()[0].model.isTollRoad == "undefined")
  66. 				W.model.segments.getObjectArray()[0].__proto__.isTollRoad = function(){ return (this.attributes.fwdToll || this.attributes.revToll);};
  67. 		}
  68. 		else{
  69. 			Waze.map.events.register("moveend", this, RestoreMissingSegmentFunctions);
  70. 			Waze.map.events.register("zoomend", this, RestoreMissingSegmentFunctions);
  71. 		}
  72. 	}
  73.  
  74.     function Geometry(){
  75.         //var geometry = WazeWrap.Geometry;
  76.  
  77.         //Converts to "normal" GPS coordinates
  78.         this.ConvertTo4326 = function (long, lat){
  79.             var projI=new OpenLayers.Projection("EPSG:900913");
  80.             var projE=new OpenLayers.Projection("EPSG:4326");
  81.             return (new OpenLayers.LonLat(long, lat)).transform(projI,projE);
  82.         };
  83.     
  84.         this.ConvertTo900913 = function (long, lat){
  85.             var projI=new OpenLayers.Projection("EPSG:900913");
  86.             var projE=new OpenLayers.Projection("EPSG:4326");
  87.             return (new OpenLayers.LonLat(long, lat)).transform(projE,projI);
  88.         };
  89.  
  90.         //Converts the Longitudinal offset to an offset in 4326 gps coordinates
  91.         this.CalculateLongOffsetGPS = function(longMetersOffset, long, lat)
  92.         {
  93.             var R= 6378137; //Earth's radius
  94.             var dLon = longMetersOffset / (R * Math.cos(Math.PI * lat / 180)); //offset in radians
  95.             var lon0 = dLon * (180 / Math.PI); //offset degrees
  96.  
  97.             return lon0;
  98.         };
  99.  
  100.         //Converts the Latitudinal offset to an offset in 4326 gps coordinates
  101.         this.CalculateLatOffsetGPS = function(latMetersOffset, lat)
  102.         {
  103.             var R= 6378137; //Earth's radius
  104.             var dLat = latMetersOffset/R;
  105.             var lat0 = dLat * (180  /Math.PI); //offset degrees
  106.  
  107.             return lat0;
  108.         };
  109. 		
  110. 		/**
  111. 		 * Checks if the given geometry is on screen
  112.          * @function WazeWrap.Geometry.isGeometryInMapExtent
  113.          * @param {OpenLayers.Geometry} Geometry to check if any part of is in the current viewport
  114.          */
  115. 		this.isLonLatInMapExtent = function (lonLat) {
  116.             'use strict';
  117.             return lonLat && W.map.getExtent().containsLonLat(lonLat);
  118.         };
  119. 		
  120. 		/**
  121. 		 * Checks if the given geometry is on screen
  122.          * @function WazeWrap.Geometry.isGeometryInMapExtent
  123.          * @param {OpenLayers.Geometry} Geometry to check if any part of is in the current viewport
  124.          */
  125. 		this.isGeometryInMapExtent = function (geometry) {
  126.             'use strict';
  127.             return geometry && geometry.getBounds &&
  128.                 W.map.getExtent().intersectsBounds(geometry.getBounds());
  129.         };
  130. 		
  131. 		/**
  132. 		 * Calculates the distance between two given points, returned in meters
  133.          * @function WazeWrap.Geometry.calculateDistance
  134.          * @param {OpenLayers.Geometry.Point} An array of OL.Geometry.Point with which to measure the total distance. A minimum of 2 points is needed.
  135.          */
  136. 		this.calculateDistance = function(pointArray) {
  137. 			if(pointArray.length < 2)
  138. 				return 0;
  139.  
  140. 			var line = new OpenLayers.Geometry.LineString(pointArray);
  141. 			length = line.getGeodesicLength(W.map.getProjectionObject());
  142. 			return length; //multiply by 3.28084 to convert to feet
  143. 		};
  144. 		
  145. 		this.findClosestSegment = function(mygeometry, ignorePLR, ignoreUnnamedPR){
  146. 			var onscreenSegments = WazeWrap.Model.getOnscreenSegments();
  147. 			var minDistance = Infinity;
  148. 			var closestSegment;
  149. 			
  150. 			for (s in onscreenSegments) {
  151. 				if (!onscreenSegments.hasOwnProperty(s))
  152. 					continue;
  153.  
  154. 				segmentType = onscreenSegments[s].attributes.roadType;
  155. 				if (segmentType === 10 || segmentType === 16 || segmentType === 18 || segmentType === 19) //10 ped boardwalk, 16 stairway, 18 railroad, 19 runway, 3 freeway
  156. 					continue;
  157. 					
  158. 				if(ignorePLR && segmentType === 20) //PLR
  159. 					continue;
  160.  
  161. 				if(ignoreUnnamedPR)
  162. 					if(segmentType === 17 && WazeWrap.Model.getStreetName(onscreenSegments[s].attributes.primaryStreetID) === null) //PR
  163. 						continue;
  164.  
  165.  
  166. 				distanceToSegment = mygeometry.distanceTo(onscreenSegments[s].geometry, {details: true});
  167.  
  168. 				if (distanceToSegment.distance < minDistance) {
  169. 					minDistance = distanceToSegment.distance;
  170. 					closestSegment = onscreenSegments[s];
  171. 					closestSegment.closestPoint = new OL.Geometry.Point(distanceToSegment.x1, distanceToSegment.y1);
  172. 				}
  173. 			}
  174. 			return closestSegment;
  175. 		};
  176.     };
  177.  
  178.     function Model(){
  179.  
  180.         this.getPrimaryStreetID = function(segmentID){
  181.             return W.model.segments.get(segmentID).attributes.primaryStreetID;
  182.         };
  183.  
  184.         this.getStreetName = function(primaryStreetID){
  185.             return W.model.streets.get(primaryStreetID).name;
  186.         };
  187.  
  188.         this.getCityID = function(primaryStreetID){
  189.             return W.model.streets.get(primaryStreetID).cityID;
  190.         };
  191.  
  192.         this.getCityName = function(primaryStreetID){
  193.             return W.model.cities.get(this.getCityID(primaryStreetID)).attributes.Name;
  194.         };
  195.  
  196.         this.getStateName = function(primaryStreetID){
  197.             return W.model.states.get(getStateID(primaryStreetID)).Name;   
  198.         };
  199.  
  200.         this.getStateID = function(primaryStreetID){
  201.             return W.model.cities.get(primaryStreetID).attributes.stateID;
  202.         };
  203.  
  204.         this.getCountryID = function(primaryStreetID){
  205.             return W.model.cities.get(this.getCityID(primaryStreetID)).attributes.CountryID;
  206.         };
  207.  
  208.         this.getCountryName = function(primaryStreetID){
  209.             return W.model.countries.get(getCountryID(primaryStreetID)).name;
  210.         };
  211.  
  212.         this.getCityNameFromSegmentObj = function(segObj){
  213.             return this.getCityName(segObj.attributes.primaryStreetID);
  214.         };
  215.  
  216.         this.getStateNameFromSegmentObj = function(segObj){
  217.             return this.getStateName(segObj.attributes.primaryStreetID);
  218.         };
  219.  
  220.         //returns an array of segmentIDs for all segments that are part of the same roundabout as the passed segment
  221.         this.getAllRoundaboutSegmentsFromObj = function(segObj){
  222.             if(segObj.model.attributes.junctionID === null)
  223.                 return null;
  224.  
  225.             return W.model.junctions.objects[segObj.model.attributes.junctionID].attributes.segIDs;
  226.         };
  227.  
  228.         this.getAllRoundaboutJunctionNodesFromObj = function(segObj){
  229.             var RASegs = this.getAllRoundaboutSegmentsFromObj(segObj);
  230.             var RAJunctionNodes = [];
  231.             for(i=0; i< RASegs.length; i++){
  232.                 RAJunctionNodes.push(W.model.nodes.objects[W.model.segments.get(RASegs[i]).attributes.toNodeID]);
  233.  
  234.             }
  235.             return RAJunctionNodes;
  236.         };
  237.  
  238.         this.isRoundaboutSegmentID = function(segmentID){
  239.             if(W.model.segments.get(segmentID).attributes.junctionID === null)
  240.                 return false;
  241.             else
  242.                 return true;
  243.         };
  244.  
  245.         this.isRoundaboutSegmentObj = function(segObj){
  246.             if(segObj.model.attributes.junctionID === null)
  247.                 return false;
  248.             else
  249.                 return true;
  250.         };
  251. 		
  252. 		this.getOnscreenSegments = function(){
  253. 			var segments = W.model.segments.objects;
  254. 			var mapExtent = W.map.getExtent();
  255. 			var onScreenSegments = [];
  256. 			var seg;
  257.  
  258. 			for (s in segments) {
  259. 				if (!segments.hasOwnProperty(s))
  260. 					continue;
  261.  
  262. 				seg = W.model.segments.get(s);
  263. 				if (mapExtent.intersectsBounds(seg.geometry.getBounds()))
  264. 					onScreenSegments.push(seg);
  265. 			}
  266. 			return onScreenSegments;
  267. 		};
  268.  
  269. /**
  270.          * Defers execution of a callback function until the WME map and data 
  271.          * model are ready. Call this function before calling a function that 
  272.          * causes a map and model reload, such as W.map.moveTo(). After the 
  273.          * move is completed the callback function will be executed.
  274.          * @function WazeWrap.Model.onModelReady
  275.          * @param {Function} callback The callback function to be executed.
  276.          * @param {Boolean} now Whether or not to call the callback now if the
  277.          * model is currently ready.
  278.          * @param {Object} context The context in which to call the callback.
  279.          */
  280.         this.onModelReady = function (callback, now, context) {
  281.             var deferModelReady = function () {
  282.                 return $.Deferred(function (dfd) {
  283.                     var resolve = function () {
  284.                         dfd.resolve();
  285.                         W.model.events.unregister('mergeend', null, resolve);
  286.                     };
  287.                     W.model.events.register('mergeend', null, resolve);
  288.                 }).promise();
  289.             };
  290.             var deferMapReady = function () {
  291.                 return $.Deferred(function (dfd) {
  292.                     var resolve = function () {
  293.                         dfd.resolve();
  294.                         W.vent.off('operationDone', resolve);
  295.                     };
  296.                     W.vent.on('operationDone', resolve);
  297.                 }).promise();
  298.             };
  299.  
  300.             if (typeof callback === 'function') {
  301.                 context = context || callback;
  302.                 if (now && WazeWrap.Util.mapReady() && WazeWrap.Util.modelReady()) {
  303.                     callback.call(context);
  304.                 } else {
  305.                     $.when(deferMapReady() && deferModelReady()).
  306.                         then(function () {
  307.                             callback.call(context);
  308.                         });
  309.                 }
  310.             }
  311.         };
  312. 		
  313. 		/**
  314.          * Retrives a route from the Waze Live Map.
  315.          * @class
  316.          * @name wLib.Model.RouteSelection
  317.          * @param firstSegment The segment to use as the start of the route.
  318.          * @param lastSegment The segment to use as the destination for the route.
  319.          * @param {Array|Function} callback A function or array of funcitons to be 
  320.          * executed after the route
  321.          * is retrieved. 'This' in the callback functions will refer to the 
  322.          * RouteSelection object.
  323.          * @param {Object} options A hash of options for determining route. Valid 
  324.          * options are:
  325.          * fastest: {Boolean} Whether or not the fastest route should be used. 
  326.          * Default is false, which selects the shortest route.
  327.          * freeways: {Boolean} Whether or not to avoid freeways. Default is false.
  328.          * dirt: {Boolean} Whether or not to avoid dirt roads. Default is false.
  329.          * longtrails: {Boolean} Whether or not to avoid long dirt roads. Default 
  330.          * is false.
  331.          * uturns: {Boolean} Whether or not to allow U-turns. Default is true.
  332.          * @return {wLib.Model.RouteSelection} The new RouteSelection object.
  333.          * @example: // The following example will retrieve a route from the Live Map and select the segments in the route.
  334.          * selection = W.selectionManager.selectedItems;
  335.          * myRoute = new wLib.Model.RouteSelection(selection[0], selection[1], function(){this.selectRouteSegments();}, {fastest: true});
  336.          */
  337.         this.RouteSelection = function (firstSegment, lastSegment, callback, options) {
  338.             var i,
  339.                 n,
  340.                 start = this.getSegmentCenterLonLat(firstSegment),
  341.                 end = this.getSegmentCenterLonLat(lastSegment);
  342.             this.options = {
  343.                 fastest: options && options.fastest || false,
  344.                 freeways: options && options.freeways || false,
  345.                 dirt: options && options.dirt || false,
  346.                 longtrails: options && options.longtrails || false,
  347.                 uturns: options && options.uturns || true
  348.             };
  349.             this.requestData = {
  350.                 from: 'x:' + start.x + ' y:' + start.y + ' bd:true',
  351.                 to: 'x:' + end.x + ' y:' + end.y + ' bd:true',
  352.                 returnJSON: true,
  353.                 returnGeometries: true,
  354.                 returnInstructions: false,
  355.                 type: this.options.fastest ? 'HISTORIC_TIME' : 'DISTANCE',
  356.                 clientVersion: '4.0.0',
  357.                 timeout: 60000,
  358.                 nPaths: 3,
  359.                 options: this.setRequestOptions(this.options)
  360.             };
  361.             this.callbacks = [];
  362.             if (callback) {
  363.                 if (!(callback instanceof Array)) {
  364.                     callback = [callback];
  365.                 }
  366.                 for (i = 0, n = callback.length; i < n; i++) {
  367.                     if ('function' === typeof callback[i]) {
  368.                         this.callbacks.push(callback[i]);
  369.                     }
  370.                 }
  371.             }
  372.             this.routeData = null;
  373.             this.getRouteData();
  374.         };
  375.  
  376. 		this.RouteSelection.prototype = 
  377.             /** @lends wLib.Model.RouteSelection.prototype */ {
  378.                 
  379.             /**
  380.              * Formats the routing options string for the ajax request.
  381.              * @private
  382.              * @param {Object} options Object containing the routing options.
  383.              * @return {String} String containing routing options.
  384.              */
  385.             setRequestOptions: function (options) {
  386.                 return 'AVOID_TOLL_ROADS:' + (options.tolls ? 't' : 'f') + ',' +
  387.                     'AVOID_PRIMARIES:' + (options.freeways ? 't' : 'f') + ',' +
  388.                     'AVOID_TRAILS:' + (options.dirt ? 't' : 'f') + ',' +
  389.                     'AVOID_LONG_TRAILS:' + (options.longtrails ? 't' : 'f') + ',' +
  390.                     'ALLOW_UTURNS:' + (options.uturns ? 't' : 'f');
  391.             },
  392.             
  393.             /**
  394.              * Gets the center of a segment in LonLat form.
  395.              * @private
  396.              * @param segment A Waze model segment object.
  397.              * @return {OpenLayers.LonLat} The LonLat object corresponding to the
  398.              * center of the segment.
  399.              */
  400.             getSegmentCenterLonLat: function (segment) {
  401.                 var x, y, componentsLength, midPoint;
  402.                 if (segment) {
  403.                     componentsLength = segment.geometry.components.length;
  404.                     midPoint = Math.floor(componentsLength / 2);
  405.                     if (componentsLength % 2 === 1) {
  406.                         x = segment.geometry.components[midPoint].x;
  407.                         y = segment.geometry.components[midPoint].y;
  408.                     } else {
  409.                         x = (segment.geometry.components[midPoint - 1].x +
  410.                             segment.geometry.components[midPoint].x) / 2;
  411.                         y = (segment.geometry.components[midPoint - 1].y +
  412.                             segment.geometry.components[midPoint].y) / 2;
  413.                     }
  414.                     return new OL.Geometry.Point(x, y).
  415.                         transform(W.map.getProjectionObject(), 'EPSG:4326');
  416.                 }
  417.  
  418.             },
  419.             
  420.             /**
  421.              * Gets the route from Live Map and executes any callbacks upon success.
  422.              * @private
  423.              * @returns The ajax request object. The responseJSON property of the 
  424.              * returned object
  425.              * contains the route information.
  426.              *
  427.              */
  428.             getRouteData: function () {
  429.                 var i,
  430.                     n,
  431.                     that = this;
  432.                 return $.ajax({
  433.                     dataType: 'json',
  434.                     url: this.getURL(),
  435.                     data: this.requestData,
  436.                     dataFilter: function (data, dataType) {
  437.                         return data.replace(/NaN/g, '0');
  438.                     },
  439.                     success: function (data) {
  440.                         that.routeData = data;
  441.                         for (i = 0, n = that.callbacks.length; i < n; i++) {
  442.                             that.callbacks[i].call(that);
  443.                         }
  444.                     }
  445.                 });
  446.             },
  447.             
  448.             /**
  449.              * Extracts the IDs from all segments on the route.
  450.              * @private
  451.              * @return {Array} Array containing an array of segment IDs for
  452.              * each route alternative.
  453.              */
  454.             getRouteSegmentIDs: function () {
  455.                 var i, j, route, len1, len2, segIDs = [],
  456.                     routeArray = [],
  457.                     data = this.routeData;
  458.                 if ('undefined' !== typeof data.alternatives) {
  459.                     for (i = 0, len1 = data.alternatives.length; i < len1; i++) {
  460.                         route = data.alternatives[i].response.results;
  461.                         for (j = 0, len2 = route.length; j < len2; j++) {
  462.                             routeArray.push(route[j].path.segmentId);
  463.                         }
  464.                         segIDs.push(routeArray);
  465.                         routeArray = [];
  466.                     }
  467.                 } else {
  468.                     route = data.response.results;
  469.                     for (i = 0, len1 = route.length; i < len1; i++) {
  470.                         routeArray.push(route[i].path.segmentId);
  471.                     }
  472.                     segIDs.push(routeArray);
  473.                 }
  474.                 return segIDs;
  475.             },
  476.             
  477.             /**
  478.              * Gets the URL to use for the ajax request based on country.
  479.              * @private
  480.              * @return {String} Relative URl to use for route ajax request.
  481.              */
  482.             getURL: function () {
  483.                 if (W.model.countries.get(235) || W.model.countries.get(40)) {
  484.                     return '/RoutingManager/routingRequest';
  485.                 } else if (W.model.countries.get(106)) {
  486.                     return '/il-RoutingManager/routingRequest';
  487.                 } else {
  488.                     return '/row-RoutingManager/routingRequest';
  489.                 }
  490.             },
  491.             
  492.             /**
  493.              * Selects all segments on the route in the editor.
  494.              * @param {Integer} routeIndex The index of the alternate route.
  495.              * Default route to use is the first one, which is 0.
  496.              */
  497.             selectRouteSegments: function (routeIndex) {
  498.                 var i, n, seg,
  499.                     segIDs = this.getRouteSegmentIDs()[Math.floor(routeIndex) || 0],
  500.                     segments = [];
  501.                 if ('undefined' === typeof segIDs) {
  502.                     return;
  503.                 }
  504.                 for (i = 0, n = segIDs.length; i < n; i++) {
  505.                     seg = W.model.segments.get(segIDs[i]);
  506.                     if ('undefined' !== seg) {
  507.                         segments.push(seg);
  508.                     }
  509.                 }
  510.                 return W.selectionManager.select(segments);
  511.             }
  512.         };
  513.     };
  514. 	
  515. 	function User(){
  516. 		this.Rank = function(){
  517. 			return W.loginManager.user.normalizedLevel;
  518. 		};
  519.  
  520. 		this.Username = function(){
  521. 			return W.loginManager.user.userName;
  522. 		};
  523.  
  524. 		this.isCM = function(){
  525. 			if(W.loginManager.user.editableCountryIDs.length > 0)
  526. 				return true;
  527. 			else
  528. 				return false;
  529. 		};
  530. 		
  531. 		this.isAM = function(){
  532. 			return W.loginManager.user.isAreaManager;
  533. 		};
  534. 	};
  535. 	
  536. 	function Require(){
  537. 		this.DragElement = function(){
  538. 			var myDragElement = OL.Class({
  539. 			started: !1,
  540. 			stopDown: !0,
  541. 			dragging: !1,
  542. 			touch: !1,
  543. 			last: null ,
  544. 			start: null ,
  545. 			lastMoveEvt: null ,
  546. 			oldOnselectstart: null ,
  547. 			interval: 0,
  548. 			timeoutId: null ,
  549. 			forced: !1,
  550. 			active: !1,
  551. 			initialize: function(e) {
  552. 				this.map = e,
  553. 				this.uniqueID = myDragElement.baseID--
  554. 			},
  555. 			callback: function(e, t) {
  556. 				if (this[e])
  557. 					return this[e].apply(this, t)
  558. 			},
  559. 			dragstart: function(e) {
  560. 				e.xy = new OL.Pixel(e.clientX - this.map.viewPortDiv.offsets[0],e.clientY - this.map.viewPortDiv.offsets[1]);
  561. 				var t = !0;
  562. 				return this.dragging = !1,
  563. 				(OL.Event.isLeftClick(e) || OL.Event.isSingleTouch(e)) && (this.started = !0,
  564. 				this.start = e.xy,
  565. 				this.last = e.xy,
  566. 				OL.Element.addClass(this.map.viewPortDiv, "olDragDown"),
  567. 				this.down(e),
  568. 				this.callback("down", [e.xy]),
  569. 				OL.Event.stop(e),
  570. 				this.oldOnselectstart || (this.oldOnselectstart = document.onselectstart ? document.onselectstart : OL.Function.True),
  571. 				document.onselectstart = OL.Function.False,
  572. 				t = !this.stopDown),
  573. 				t
  574. 			},
  575. 			forceStart: function() {
  576. 				var e = arguments.length > 0 && void 0 !== arguments[0] && arguments[0];
  577. 				return this.started = !0,
  578. 				this.endOnMouseUp = e,
  579. 				this.forced = !0,
  580. 				this.last = {
  581. 					x: 0,
  582. 					y: 0
  583. 				},
  584. 				this.callback("force")
  585. 			},
  586. 			forceEnd: function() {
  587. 				if (this.forced)
  588. 					return this.endDrag()
  589. 			},
  590. 			dragmove: function(e) {
  591. 				return this.map.viewPortDiv.offsets && (e.xy = new OL.Pixel(e.clientX - this.map.viewPortDiv.offsets[0],e.clientY - this.map.viewPortDiv.offsets[1])),
  592. 				this.lastMoveEvt = e,
  593. 				!this.started || this.timeoutId || e.xy.x === this.last.x && e.xy.y === this.last.y || (this.interval > 0 && (this.timeoutId = window.setTimeout(OL.Function.bind(this.removeTimeout, this), this.interval)),
  594. 				this.dragging = !0,
  595. 				this.move(e),
  596. 				this.oldOnselectstart || (this.oldOnselectstart = document.onselectstart,
  597. 				document.onselectstart = OL.Function.False),
  598. 				this.last = e.xy),
  599. 				!0
  600. 			},
  601. 			dragend: function(e) {
  602. 				if (e.xy = new OL.Pixel(e.clientX - this.map.viewPortDiv.offsets[0],e.clientY - this.map.viewPortDiv.offsets[1]),
  603. 				this.started) {
  604. 					var t = this.start !== this.last;
  605. 					this.endDrag(),
  606. 					this.up(e),
  607. 					this.callback("up", [e.xy]),
  608. 					t && this.callback("done", [e.xy])
  609. 				}
  610. 				return !0
  611. 			},
  612. 			endDrag: function() {
  613. 				this.started = !1,
  614. 				this.dragging = !1,
  615. 				this.forced = !1,
  616. 				OL.Element.removeClass(this.map.viewPortDiv, "olDragDown"),
  617. 				document.onselectstart = this.oldOnselectstart;
  618. 			},
  619. 			down: function(e) {},
  620. 			move: function(e) {},
  621. 			up: function(e) {},
  622. 			out: function(e) {},
  623. 			mousedown: function(e) {
  624. 				return this.dragstart(e);
  625. 			},
  626. 			touchstart: function(e) {
  627. 				return this.touch || (this.touch = !0,
  628. 				this.map.events.un({
  629. 					mousedown: this.mousedown,
  630. 					mouseup: this.mouseup,
  631. 					mousemove: this.mousemove,
  632. 					click: this.click,
  633. 					scope: this
  634. 				})),
  635. 				this.dragstart(e);
  636. 			},
  637. 			mousemove: function(e) {
  638. 				return this.dragmove(e);
  639. 			},
  640. 			touchmove: function(e) {
  641. 				return this.dragmove(e);
  642. 			},
  643. 			removeTimeout: function() {
  644. 				if (this.timeoutId = null ,
  645. 				this.dragging)
  646. 					return this.mousemove(this.lastMoveEvt);
  647. 			},
  648. 			mouseup: function(e) {
  649. 				if (!this.forced || this.endOnMouseUp)
  650. 					return this.started ? this.dragend(e) : void 0;
  651. 			},
  652. 			touchend: function(e) {
  653. 				if (e.xy = this.last,
  654. 				!this.forced)
  655. 					return this.dragend(e);
  656. 			},
  657. 			click: function(e) {
  658. 				return this.start === this.last;
  659. 			},
  660. 			activate: function(e) {
  661. 				this.$el = e,
  662. 				this.active = !0;
  663. 				var t = $(this.map.viewPortDiv);
  664. 				return this.$el.on("mousedown.drag-" + this.uniqueID, $.proxy(this.mousedown, this)),
  665. 				this.$el.on("touchstart.drag-" + this.uniqueID, $.proxy(this.touchstart, this)),
  666. 				$(document).on("mouseup.drag-" + this.uniqueID, $.proxy(this.mouseup, this)),
  667. 				t.on("mousemove.drag-" + this.uniqueID, $.proxy(this.mousemove, this)),
  668. 				t.on("touchmove.drag-" + this.uniqueID, $.proxy(this.touchmove, this)),
  669. 				t.on("touchend.drag-" + this.uniqueID, $.proxy(this.touchend, this));
  670. 			},
  671. 			deactivate: function() {
  672. 				return this.active = !1,
  673. 				this.$el.off(".drag-" + this.uniqueID),
  674. 				$(this.map.viewPortDiv).off(".drag-" + this.uniqueID),
  675. 				$(document).off(".drag-" + this.uniqueID),
  676. 				this.touch = !1,
  677. 				this.started = !1,
  678. 				this.forced = !1,
  679. 				this.dragging = !1,
  680. 				this.start = null ,
  681. 				this.last = null ,
  682. 				OL.Element.removeClass(this.map.viewPortDiv, "olDragDown");
  683. 			},
  684. 			adjustXY: function(e) {
  685. 				var t = OL.Util.pagePosition(this.map.viewPortDiv);
  686. 				return e.xy.x -= t[0],
  687. 				e.xy.y -= t[1];
  688. 			},
  689. 			CLASS_NAME: "W.Handler.DragElement"
  690. 			});
  691.                  myDragElement.baseID = 0;
  692. 				 return myDragElement;
  693. 		 };
  694. 	
  695. 		this.DivIcon = OpenLayers.Class({
  696. 			className: null ,
  697. 			$div: null ,
  698. 			events: null ,
  699. 			initialize: function(e, t) {
  700. 				this.className = e,
  701. 					this.moveWithTransform = !!t,
  702. 					this.$div = $("<div />").addClass(e),
  703. 					this.div = this.$div.get(0),
  704. 					this.imageDiv = this.$div.get(0);
  705. 			},
  706. 			destroy: function() {
  707. 				this.erase(),
  708. 					this.$div = null;
  709. 			},
  710. 			clone: function() {
  711. 				return new i(this.className);
  712. 			},
  713. 			draw: function(e) {
  714. 				return this.moveWithTransform ? (this.$div.css({
  715. 					transform: "translate(" + e.x + "px, " + e.y + "px)"
  716. 				}),
  717. 												 this.$div.css({
  718. 					position: "absolute"
  719. 				})) : this.$div.css({
  720. 					position: "absolute",
  721. 					left: e.x,
  722. 					top: e.y
  723. 				}),
  724. 					this.$div.get(0);
  725. 			},
  726. 			moveTo: function(e) {
  727. 				null !== e && (this.px = e),
  728. 					null === this.px ? this.display(!1) : this.moveWithTransform ? this.$div.css({
  729. 					transform: "translate(" + this.px.x + "px, " + this.px.y + "px)"
  730. 				}) : this.$div.css({
  731. 					left: this.px.x,
  732. 					top: this.px.y
  733. 				});
  734. 			},
  735. 			erase: function() {
  736. 				this.$div.remove();
  737. 			},
  738. 			display: function(e) {
  739. 				this.$div.toggle(e);
  740. 			},
  741. 			isDrawn: function() {
  742. 				return !!this.$div.parent().length;
  743. 			},
  744. 			bringToFront: function() {
  745. 				if (this.isDrawn()) {
  746. 					var e = this.$div.parent();
  747. 					this.$div.detach().appendTo(e);
  748. 				}
  749. 			},
  750. 			forceReflow: function() {
  751. 				return this.$div.get(0).offsetWidth;
  752. 			},
  753. 			CLASS_NAME: "Waze.DivIcon"
  754. 		});
  755. 	};
  756. 	
  757. 	
  758. 	function Util(){
  759. 		/**
  760.          * Function to defer function execution until an element is present on 
  761.          * the page.
  762.          * @function WazeWrap.Util.waitForElement
  763.          * @param {String} selector The CSS selector string or a jQuery object 
  764.          * to find before executing the callback.
  765.          * @param {Function} callback The function to call when the page 
  766.          * element is detected.
  767.          * @param {Object} [context] The context in which to call the callback.
  768.          */
  769.         this.waitForElement = function (selector, callback, context) {
  770.             var jqObj;
  771.  
  772.             if (!selector || typeof callback !== 'function') {
  773.                 return;
  774.             }
  775.  
  776.             jqObj = typeof selector === 'string' ?
  777.                 $(selector) : selector instanceof $ ? selector : null;
  778.  
  779.             if (!jqObj.size()) {
  780.                 window.requestAnimationFrame(function () {
  781.                     WazeWrap.Util.waitForElement(selector, callback, context);
  782.                 });
  783.             } else {
  784.                 callback.call(context || callback);
  785.             }
  786.         };
  787.  
  788.          /**
  789.          * Function to track the ready state of the map.
  790.          * @function WazeWrap.Util.mapReady
  791.          * @return {Boolean} Whether or not a map operation is pending or 
  792.          * undefined if the function has not yet seen a map ready event fired.
  793.          */
  794.         this.mapReady = function () {
  795.             var mapReady = true;
  796.             W.vent.on('operationPending', function () {
  797.                 mapReady = false;
  798.             });
  799.             W.vent.on('operationDone', function () {
  800.                 mapReady = true;
  801.             });
  802.             return function () {
  803.                 return mapReady;
  804.             };
  805.         } ();
  806.  
  807.          /**
  808.          * Function to track the ready state of the model.
  809.          * @function WazeWrap.Util.modelReady
  810.          * @return {Boolean} Whether or not the model has loaded objects or 
  811.          * undefined if the function has not yet seen a model ready event fired.
  812.          */
  813.         this.modelReady = function () {
  814.             var modelReady = true;
  815.             W.model.events.register('mergestart', null, function () {
  816.                 modelReady = false;
  817.             });
  818.             W.model.events.register('mergeend', null, function () {
  819.                 modelReady = true;
  820.             });
  821.             return function () {
  822.                 return modelReady;
  823.             };
  824.         } ();
  825. 	}
  826.  
  827.     function Interface() {
  828.         /**
  829.          * Generates id for message bars.
  830.          * @private
  831.          */
  832.         var getNextID = function () {
  833.             var id = 1;
  834.             return function () {
  835.                 return id++;
  836.             };
  837.         } ();
  838. 		
  839.         this.Shortcut = OL.Class(this, /** @lends WazeWrap.Interface.Shortcut.prototype */ {
  840.             name: null,
  841.             desc: null,
  842.             group: null,
  843.             title: null,
  844.             shortcut: {},
  845.             callback: null,
  846.             scope: null,
  847.             groupExists: false,
  848.             actionExists: false,
  849.             eventExists: false,
  850.             defaults: {
  851.                 group: 'default'
  852.             },
  853.                 
  854.             /**
  855.              * Creates a new {WazeWrap.Interface.Shortcut}.
  856.              * @class
  857.              * @name WazeWrap.Interface.Shortcut
  858.              * @param name {String} The name of the shortcut.
  859.              * @param desc {String} The description to display for the shortcut
  860.              * @param group {String} The name of the shortcut group.
  861.              * @param title {String} The title to display for this group in the Keyboard shortcuts list
  862.              * @param shortcut {String} The shortcut key(s). The shortcut  
  863.              * should be of the form 'i' where i is the keyboard shortuct or 
  864.              * include modifier keys  such as 'CSA+i', where C = the control 
  865.              * key, S = the shift key, A = the alt key, and i = the desired 
  866.              * keyboard shortcut. The modifier keys are optional.
  867.              * @param callback {Function} The function to be called by the 
  868.              * shortcut.
  869.              * @param scope {Object} The object to be used as this by the 
  870.              * callback.
  871.              * @return {WazeWrap.Interface.Shortcut} The new shortcut object.
  872.              * @example //Creates new shortcut and adds it to the map.
  873.              * shortcut = new WazeWrap.Interface.Shortcut('myName', 'myGroup', 'C+p', callbackFunc, null).add();
  874.              */
  875.             initialize: function (name, desc, group, title, shortcut, callback, scope) {
  876.                 if ('string' === typeof name && name.length > 0 &&
  877.                     'string' === typeof shortcut &&
  878.                     'function' === typeof callback) {
  879.                     this.name = name;
  880.                     this.desc = desc;
  881.                     this.group = group || this.defaults.group;
  882.                     this.title = title;
  883.                     this.callback = callback;
  884.                     this.shortcut[shortcut] = name;
  885.                     if ('object' !== typeof scope) {
  886.                         this.scope = null;
  887.                     } else {
  888.                         this.scope = scope;
  889.                     }
  890.                     return this;
  891.                 }
  892.             },
  893.                 
  894.             /**
  895.             * Determines if the shortcut's group already exists.
  896.             * @private
  897.             */
  898.             doesGroupExist: function () {
  899.                 this.groupExists = 'undefined' !== typeof W.accelerators.Groups[this.group] &&
  900.                 undefined !== typeof W.accelerators.Groups[this.group].members;
  901.                 return this.groupExists;
  902.             },
  903.                 
  904.             /**
  905.             * Determines if the shortcut's action already exists.
  906.             * @private
  907.             */
  908.             doesActionExist: function () {
  909.                 this.actionExists = 'undefined' !== typeof W.accelerators.Actions[this.name];
  910.                 return this.actionExists;
  911.             },
  912.                 
  913.             /**
  914.             * Determines if the shortcut's event already exists.
  915.             * @private
  916.             */
  917.             doesEventExist: function () {
  918.                 this.eventExists = 'undefined' !== typeof W.accelerators.events.listeners[this.name] &&
  919.                 W.accelerators.events.listeners[this.name].length > 0 &&
  920.                 this.callback === W.accelerators.events.listeners[this.name][0].func &&
  921.                 this.scope === W.accelerators.events.listeners[this.name][0].obj;
  922.                 return this.eventExists;
  923.             },
  924.                 
  925.             /**
  926.             * Creates the shortcut's group.
  927.             * @private
  928.             */
  929.             createGroup: function () {
  930.                 W.accelerators.Groups[this.group] = [];
  931.                 W.accelerators.Groups[this.group].members = [];
  932.  
  933.                 if(this.title && !I18n.translations[I18n.currentLocale()].keyboard_shortcuts.groups[this.group]){
  934.                     I18n.translations[I18n.currentLocale()].keyboard_shortcuts.groups[this.group] = [];
  935.                     I18n.translations[I18n.currentLocale()].keyboard_shortcuts.groups[this.group].description = this.title;
  936.                     I18n.translations[I18n.currentLocale()].keyboard_shortcuts.groups[this.group].members = [];
  937.                 }
  938.             },
  939.                 
  940.             /**
  941.             * Registers the shortcut's action.
  942.             * @private
  943.             */
  944.             addAction: function () {
  945.                 if(this.title)
  946.                     I18n.translations[I18n.currentLocale()].keyboard_shortcuts.groups[this.group].members[this.name] = this.desc;
  947.                 W.accelerators.addAction(this.name, { group: this.group });
  948.             },
  949.                 
  950.             /**
  951.             * Registers the shortcut's event.
  952.             * @private
  953.             */
  954.             addEvent: function () {
  955.                 W.accelerators.events.register(this.name, this.scope, this.callback);
  956.             },
  957.                 
  958.             /**
  959.             * Registers the shortcut's keyboard shortcut.
  960.             * @private
  961.             */
  962.             registerShortcut: function () {
  963.                 W.accelerators._registerShortcuts(this.shortcut);
  964.             },
  965.                 
  966.             /**
  967.             * Adds the keyboard shortcut to the map.
  968.             * @return {WazeWrap.Interface.Shortcut} The keyboard shortcut.
  969.             */
  970.             add: function () {
  971.                 /* If the group is not already defined, initialize the group. */
  972.                 if (!this.doesGroupExist()) {
  973.                     this.createGroup();
  974.                 }
  975.  
  976.                 /* Clear existing actions with same name */
  977.                 if (this.doesActionExist()) {
  978.                     W.accelerators.Actions[this.name] = null;
  979.                 }
  980.                 this.addAction();
  981.  
  982.                 /* Register event only if it's not already registered */
  983.                 if (!this.doesEventExist()) {
  984.                     this.addEvent();
  985.                 }
  986.  
  987.                 /* Finally, register the shortcut. */
  988.                 this.registerShortcut();
  989.                 return this;
  990.             },
  991.                 
  992.             /**
  993.             * Removes the keyboard shortcut from the map.
  994.             * @return {WazeWrap.Interface.Shortcut} The keyboard shortcut.
  995.             */
  996.             remove: function () {
  997.                 if (this.doesEventExist()) {
  998.                     W.accelerators.events.unregister(this.name, this.scope, this.callback);
  999.                 }
  1000.                 if (this.doesActionExist()) {
  1001.                     delete W.accelerators.Actions[this.name];
  1002.                 }
  1003.                 //remove shortcut?
  1004.                 return this;
  1005.             },
  1006.                 
  1007.             /**
  1008.             * Changes the keyboard shortcut and applies changes to the map.
  1009.             * @return {WazeWrap.Interface.Shortcut} The keyboard shortcut.
  1010.             */
  1011.             change: function (shortcut) {
  1012.                 if (shortcut) {
  1013.                     this.shortcut = {};
  1014.                     this.shortcut[shortcut] = this.name;
  1015.                     this.registerShortcut();
  1016.                 }
  1017.                 return this;
  1018.             }
  1019.         });
  1020.  
  1021. 		this.Tab = class Tab{
  1022. 			constructor(name, content, callback, context){
  1023. 				this.TAB_SELECTOR = '#user-tabs ul.nav-tabs';
  1024. 				this.CONTENT_SELECTOR = '#user-info div.tab-content';
  1025. 				this.callback = null;
  1026. 				this.$content = null;
  1027. 				this.context = null;
  1028. 				this.$tab = null;
  1029. 				
  1030. 				 let idName, i = 0;
  1031. 				
  1032. 				if (name && 'string' === typeof name &&
  1033. 					content && 'string' === typeof content) {
  1034. 					if (callback && 'function' === typeof callback) {
  1035. 						this.callback = callback;
  1036. 						this.context = context || callback;
  1037. 					}
  1038. 					/* Sanitize name for html id attribute */
  1039. 					idName = name.toLowerCase().replace(/[^a-z-_]/g, '');
  1040. 					/* Make sure id will be unique on page */
  1041. 					while (
  1042. 						$('#sidepanel-' + (i ? idName + i : idName)).length > 0) {
  1043. 						i++;
  1044. 					}
  1045. 					if (i) {
  1046. 						idName = idName + i;
  1047. 					}
  1048. 					/* Create tab and content */
  1049. 					this.$tab = $('<li/>')
  1050. 						.append($('<a/>')
  1051. 							.attr({
  1052. 								'href': '#sidepanel-' + idName,
  1053. 								'data-toggle': 'tab',
  1054. 							})
  1055. 							.text(name));
  1056. 					this.$content = $('<div/>')
  1057. 						.addClass('tab-pane')
  1058. 						.attr('id', 'sidepanel-' + idName)
  1059. 						.html(content);
  1060.  
  1061. 					this.appendTab();
  1062. 					let that = this;
  1063. 					if (Waze.prefs) {
  1064. 						Waze.prefs.on('change:isImperial', function(){that.appendTab();});
  1065. 					}
  1066. 					Waze.app.modeController.model.bind('change:mode', function(){that.appendTab();});
  1067. 						}
  1068. 					}
  1069. 			
  1070. 			append(content){
  1071. 				this.$content.append(content);
  1072. 			}
  1073. 			
  1074. 			appendTab(){
  1075. 				WazeWrap.Util.waitForElement(
  1076. 					this.TAB_SELECTOR + ',' + this.CONTENT_SELECTOR,
  1077. 					function () {
  1078. 						$(this.TAB_SELECTOR).append(this.$tab);
  1079. 						$(this.CONTENT_SELECTOR).first().append(this.$content);
  1080. 						if (this.callback) {
  1081. 							this.callback.call(this.context);
  1082. 						}
  1083. 					}, this);
  1084. 			}
  1085. 			
  1086. 			clearContent(){
  1087. 				this.$content.empty();
  1088. 			}
  1089. 			
  1090. 			destroy(){
  1091. 				this.$tab.remove();
  1092. 				this.$content.remove();
  1093. 			}
  1094. 		}
  1095.  
  1096. 		this.AddLayerCheckbox = function(group, checkboxText, checked, callback){
  1097. 			group = group.toLowerCase();
  1098. 			var normalizedText = checkboxText.toLowerCase().replace(/\s/g, '_');
  1099. 			var checkboxID = "layer-switcher-item_" + normalizedText;
  1100. 			var groupPrefix = 'layer-switcher-group_';
  1101. 			var groupClass = groupPrefix + group.toLowerCase();
  1102. 			sessionStorage[normalizedText] = checked;
  1103.  
  1104. 			var CreateParentGroup = function(groupChecked){
  1105. 				var groupList = $('.layer-switcher').find('.list-unstyled.togglers');
  1106. 				var checkboxText = group.charAt(0).toUpperCase() + group.substr(1);
  1107. 				var newLI = $('<li class="group">');
  1108. 				newLI.html([
  1109. 					'<div class="controls-container toggler">',
  1110. 					'<input class="' + groupClass + '" id="' + groupClass + '" type="checkbox" ' + (groupChecked ? 'checked' : '') +'>',
  1111. 					'<label for="' + groupClass + '">',
  1112. 					'<span class="label-text">'+ checkboxText + '</span>',
  1113. 					'</label></div>',
  1114. 					'<ul class="children"></ul>'
  1115. 					].join(' '));
  1116.  
  1117. 				groupList.append(newLI);
  1118. 				$('#' + groupClass).change(function(){sessionStorage[groupClass] = this.checked;});
  1119. 			};
  1120.  
  1121. 			if(group !== "issues" && group !== "places" && group !== "road" && group !== "display") //"non-standard" group, check its existence
  1122. 				if($('.'+groupClass).length === 0){ //Group doesn't exist yet, create it
  1123. 					var isParentChecked = (typeof sessionStorage[groupClass] == "undefined" ? true : sessionStorage[groupClass]=='true');
  1124. 					CreateParentGroup(isParentChecked);  //create the group
  1125. 					sessionStorage[groupClass] = isParentChecked;
  1126.  
  1127. 					Waze.app.modeController.model.bind('change:mode', function(model, modeId, context){ //make it reappear after changing modes
  1128. 						CreateParentGroup((sessionStorage[groupClass]=='true'));
  1129. 					});
  1130. 				}
  1131.  
  1132. 			var buildLayerItem = function(isChecked){
  1133. 				var groupChildren = $("."+groupClass).parent().parent().find('.children').not('.extended');
  1134. 				$li = $('<li>');
  1135. 				$li.html([
  1136. 					'<div class="controls-container toggler">',
  1137. 					'<input type="checkbox" id="' + checkboxID + '"  class="' + checkboxID + ' toggle">',
  1138. 					'<label for="' + checkboxID + '"><span class="label-text">' + checkboxText + '</span></label>',
  1139. 					'</div>',
  1140. 				].join(' '));
  1141.  
  1142. 				groupChildren.append($li);
  1143. 				$('#' + checkboxID).prop('checked', isChecked);
  1144. 				$('#' + checkboxID).change(function(){callback(this.checked); sessionStorage[normalizedText] = this.checked;});
  1145. 				if(!$('#' + groupClass).is(':checked')){
  1146. 					$('#' + checkboxID).prop('disabled', true);
  1147. 					callback(false);
  1148. 				}
  1149.  
  1150. 				$('#' + groupClass).change(function(){$('#' + checkboxID).prop('disabled', !this.checked); callback(this.checked);});
  1151. 			};
  1152.  
  1153.  
  1154. 			Waze.app.modeController.model.bind('change:mode', function(model, modeId, context){
  1155. 				buildLayerItem((sessionStorage[normalizedText]=='true'));
  1156. 			});
  1157.  
  1158. 			buildLayerItem(checked);
  1159. 		};
  1160.     }
  1161.  
  1162. 	function String(){
  1163. 		this.toTitleCase = function(str){
  1164. 			return str.replace(/(?:^|\s)\w/g, function(match) {
  1165. 				return match.toUpperCase();
  1166. 			});
  1167. 		};
  1168. 	}
  1169. }.call(this));

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址