☰

WazeWrapBeta

A base library for WME script writers

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

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

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

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

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

加入Q群

QingJ © 2025

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